Reject poly functions with erased parameters

Author: natsukagami

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1434,13 +1434,30 @@ object Parsers {
      */
     def toplevelTyp(): Tree = rejectWildcardType(typ())
 
-    private def isFunction(tree: Tree): Boolean = tree match {
-      case Parens(tree1) => isFunction(tree1)
-      case Block(Nil, tree1) => isFunction(tree1)
-      case _: Function => true
-      case _ => false
+    private def getFunction(tree: Tree): Option[Function] = tree match {
+      case Parens(tree1) => getFunction(tree1)
+      case Block(Nil, tree1) => getFunction(tree1)
+      case t: Function => Some(t)
+      case _ => None
     }
 
+    private def checkFunctionNotErased(f: Function, context: String) =
+      def fail(span: Span) =
+        syntaxError(em"Implementation restriction: erased parameters are not supported in $context", span)
+      // erased parameter in type
+      val hasErasedParam = f match
+        case f: FunctionWithMods => f.hasErasedParams
+        case _ => false
+      if hasErasedParam then
+        fail(f.span)
+      // erased parameter in term
+      val hasErasedMods = f.args.collectFirst {
+        case v: ValDef if v.mods.is(Flags.Erased) => v
+      }
+      hasErasedMods match
+        case Some(param) => fail(param.span)
+        case _ =>
+
     /** CaptureRef  ::=  ident | `this`
      */
     def captureRef(): Tree =
@@ -1580,11 +1597,13 @@ object Parsers {
             val arrowOffset = in.skipToken()
             val body = toplevelTyp()
             atSpan(start, arrowOffset) {
-              if (isFunction(body))
-                PolyFunction(tparams, body)
-              else {
-                syntaxError(em"Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
-                Ident(nme.ERROR.toTypeName)
+              getFunction(body) match {
+                case Some(f) =>
+                  checkFunctionNotErased(f, "poly function")
+                  PolyFunction(tparams, body)
+                case None =>
+                  syntaxError(em"Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
+                  Ident(nme.ERROR.toTypeName)
               }
             }
           }
@@ -2113,12 +2132,13 @@ object Parsers {
           val arrowOffset = accept(ARROW)
           val body = expr(location)
           atSpan(start, arrowOffset) {
-            if (isFunction(body))
-              PolyFunction(tparams, body)
-            else {
-              syntaxError(em"Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
-              errorTermTree(arrowOffset)
-            }
+            getFunction(body) match
+              case Some(f) =>
+                checkFunctionNotErased(f, "poly function")
+                PolyFunction(tparams, f)
+              case None =>
+                syntaxError(em"Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+                errorTermTree(arrowOffset)
           }
         case _ =>
           val saved = placeholderParams

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

@@ -2614,6 +2614,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
+      // check PolyFunction constraints (no erased functions!)
+      if parents1.exists(_.tpe.classSymbol eq defn.PolyFunctionClass) then
+        body1.foreach {
+          case ddef: DefDef =>
+            ddef.paramss.foreach { params =>
+              val erasedParam = params.collectFirst { case vdef: ValDef if vdef.symbol.is(Erased) => vdef }
+              erasedParam.foreach { p =>
+                report.error(em"Implementation restriction: erased classes are not allowed in a poly function definition", p.srcPos)
+              }
+            }
+          case _ =>
+        }
+
       val effectiveOwner = cls.owner.skipWeakOwner
       if !cls.isRefinementClass
          && !cls.isAllOf(PrivateLocal)

tests/neg-custom-args/erased/poly-functions.scala

@@ -0,0 +1,16 @@
+object Test:
+  // Poly functions with erased parameters are disallowed as an implementation restriction
+
+  type T1 = [X] => (erased x: X, y: Int) => Int // error
+  type T2 = [X] => (x: X, erased y: Int) => X // error
+
+  val t1 = [X] => (erased x: X, y: Int) => y // error
+  val t2 = [X] => (x: X, erased y: Int) => x // error
+
+  // Erased classes should be detected too
+  erased class A
+
+  type T3 = [X] => (x: A, y: X) => X // error
+
+  val t3 = [X] => (x: A, y: X) => y // error
+