Implement parsing for multiple parameter lambdas with erased parameters

Contextual lambdas with erased parameters are also automatically supported.

Author: natsukagami

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

@@ -2095,12 +2095,9 @@ object Parsers {
 
     def expr(location: Location): Tree = {
       val start = in.offset
-      def isSpecialClosureStart = in.lookahead.isIdent(nme.erased) && in.erasedEnabled
       in.token match
         case IMPLICIT =>
           closure(start, location, modifiers(BitSet(IMPLICIT)))
-        case LPAREN if isSpecialClosureStart =>
-          closure(start, location, Modifiers())
         case LBRACKET =>
           val start = in.offset
           val tparams = typeParamClause(ParamOwner.TypeParam)
@@ -2323,10 +2320,7 @@ object Parsers {
           Nil
         else
           try
-            commaSeparated(() =>
-              val mods1 = if isErased then addModifier(mods) else mods
-              binding(mods1)
-            )
+            commaSeparated(() => binding(mods))
           finally
             accept(RPAREN)
       else {
@@ -2350,10 +2344,13 @@ object Parsers {
         (atSpan(start) { makeParameter(name, t, mods) }) :: Nil
       }
 
-    /**  Binding           ::= (id | `_') [`:' Type]
+    /**  Binding           ::= [`erased`] (id | `_') [`:' Type]
      */
     def binding(mods: Modifiers): Tree =
-      atSpan(in.offset) { makeParameter(bindingName(), typedOpt(), mods) }
+      atSpan(in.offset) {
+        val mods1 = if isErased then addModifier(mods) else mods
+        makeParameter(bindingName(), typedOpt(), mods1)
+      }
 
     def bindingName(): TermName =
       if (in.token == USCORE) {
@@ -2550,6 +2547,7 @@ object Parsers {
       else in.currentRegion.withCommasExpected {
         var isFormalParams = false
         def exprOrBinding() =
+          if isErased then isFormalParams = true
           if isFormalParams then binding(Modifiers())
           else
             val t = exprInParens()

tests/neg-custom-args/erased/lambda-infer.scala

@@ -0,0 +1,23 @@
+type F = (Int, erased Int) => Int
+
+erased class A
+
+@main def Test() =
+  val a: F = (x, y) => x + 1 // error: Expected F got (Int, Int) => Int
+  val b: F = (x, erased y) => x + 1 // ok
+  val c: F = (_, _) => 5 // error: Expected F got (Int, Int) => Int
+  val d: F = (_, erased _) => 5 // ok
+
+  def use(f: F) = f(5, 6)
+
+  use { (x, y) => x } // error: Expected F got (Int, Int) => Int
+
+  def singleParam(f: (erased Int) => Int) = f(5)
+
+  singleParam(x => 5) // error: Expected (erased Int) => Int got Int => Int
+  singleParam((erased x) => 5) // ok
+
+  def erasedClass(f: A => Int) = f(new A)
+
+  erasedClass(_ => 5) // ok since A is implicitly erased
+

tests/run-custom-args/erased/lambdas.scala

@@ -0,0 +1,32 @@
+// lambdas should parse and work
+
+type F = (Int, erased String) => Int
+
+def use(f: F) = f(5, "a")
+
+val fv: F = (x, erased y) => x
+val fvExpl = (x: Int, erased y: String) => x
+
+// contextual lambdas should work
+
+type FC = (Int, erased String) ?=> Int
+
+def useCtx(f: FC) = f(using 5, "a")
+
+val fCv: FC = (x, erased y) ?=> x
+val fCvExpl = (x: Int, erased y: String) ?=> x
+
+// nested lambdas should work
+
+val nested: Int => (String, erased Int) => FC = a => (_, erased _) => (c, erased d) ?=> a + c
+
+@main def Test() =
+  assert(5 == use(fv))
+  assert(5 == use(fvExpl))
+  assert(5 == use { (x, erased y) => x })
+
+  assert(5 == useCtx(fCv))
+  assert(5 == useCtx(fCvExpl))
+  assert(5 == useCtx { (x, erased y) ?=> x })
+
+  assert(6 == useCtx(nested(1)("b", 2)))