Implement parsing for multiple parameter lambdas with erased parameters

Contextual lambdas with erased parameters are also automatically supported.
Also reject normal tuples with ValDefs in them. This comes up when trying to parse parameters out of tuples.

Author: natsukagami

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

@@ -463,6 +463,15 @@ object Parsers {
         case _ =>
           fail()
 
+    /** Checks that tuples don't contain a parameter. */
+    def checkNonParamTuple(t: Tree) = t match
+      case Tuple(ts) => ts.collectFirst {
+        case param: ValDef =>
+          syntaxError(em"invalid parameter definition syntax in tuple value", param.span)
+      }
+      case _ =>
+
+
     /** Convert (qual)ident to type identifier
      */
     def convertToTypeId(tree: Tree): Tree = tree match {
@@ -2095,12 +2104,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)
@@ -2130,7 +2136,9 @@ object Parsers {
           else if isWildcard(t) then
             placeholderParams = placeholderParams ::: saved
             t
-          else wrapPlaceholders(t)
+          else
+            checkNonParamTuple(t)
+            wrapPlaceholders(t)
     }
 
     def expr1(location: Location = Location.ElseWhere): Tree = in.token match
@@ -2323,10 +2331,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 +2355,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 +2558,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/erased-in-tuples.scala

@@ -0,0 +1,16 @@
+@main def Test() =
+  val x = 5
+  val y = 7
+
+  val t1 = (x, erased y) // error
+  val t2 = (erased x, y) // error
+  val t1a = (x: Int, erased y: Int) // error
+  val t2a = (erased x: Int, y: Int) // error
+
+  val nest = (x, (x, erased y)) // error
+
+  def use(f: (Int, Int) => Any) = f(5, 6)
+
+  use((_, erased _)) // error
+
+  (x, erased y) // error

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,38 @@
+// lambdas should parse and work
+
+type F = (erased Int, String) => String
+type S = (Int, erased String) => Int
+
+def useF(f: F) = f(5, "a")
+def useS(f: S) = f(5, "a")
+
+val ff: F = (erased x, y) => y
+
+val fs: S = (x, erased y) => x
+val fsExpl = (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("a" == useF(ff))
+
+  assert(5 == useS(fs))
+  assert(5 == useS(fsExpl))
+  assert(5 == useS { (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)))