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 {
@@ -2127,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

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/run-custom-args/erased/lambdas.scala

@@ -1,11 +1,15 @@
 // lambdas should parse and work
 
-type F = (Int, erased String) => Int
+type F = (erased Int, String) => String
+type S = (Int, erased String) => Int
 
-def use(f: F) = f(5, "a")
+def useF(f: F) = f(5, "a")
+def useS(f: S) = f(5, "a")
 
-val fv: F = (x, erased y) => x
-val fvExpl = (x: Int, erased y: String) => x
+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
 
@@ -21,9 +25,11 @@ val fCvExpl = (x: Int, erased y: String) ?=> x
 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("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))