Simplify erased parameter syntax

erased is not always a modifier on the parameter name. The syntax `erased Type` is dropped.
There's not really a need for this syntactic inconsistency.

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

@@ -1631,7 +1631,7 @@ object Parsers {
                     () => funParam(in.offset, imods))
                 case t =>
                   def funArg() =
-                    addErased()
+                    erasedArgs.addOne(false)
                     funArgType()
                   commaSeparatedRest(t, funArg)
           accept(RPAREN)

tests/neg/lambda-infer.scala

@@ -1,6 +1,6 @@
 //> using options -language:experimental.erasedDefinitions
 
-type F = (Int, erased Int) => Int
+type F = (x: Int, erased y: Int) => Int
 
 erased class A
 
@@ -14,7 +14,7 @@ erased class A
 
   use { (x, y) => x } // error: Expected F got (Int, Int) => Int
 
-  def singleParam(f: (erased Int) => Int) = f(5)
+  def singleParam(f: (erased x: Int) => Int) = f(5)
 
   singleParam(x => 5) // error: Expected (erased Int) => Int got Int => Int
   singleParam((erased x) => 5) // ok

tests/neg/polymorphic-erased-functions-types.check

@@ -5,11 +5,11 @@
   |                            Required: [T] => (x$1: T) => Unit
   |
   | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/polymorphic-erased-functions-types.scala:4:37 ---------------------------------
-4 |def t1b: [T] => (erased T) => Unit = [T] => (t: T) => () // error
-  |                                     ^^^^^^^^^^^^^^^^^^^
-  |                                     Found:    [T] => (t: T) => Unit
-  |                                     Required: [T] => (erased x$1: T) => Unit
+-- [E007] Type Mismatch Error: tests/neg/polymorphic-erased-functions-types.scala:4:40 ---------------------------------
+4 |def t1b: [T] => (erased t: T) => Unit = [T] => (t: T) => () // error
+  |                                        ^^^^^^^^^^^^^^^^^^^
+  |                                        Found:    [T] => (t: T) => Unit
+  |                                        Required: [T] => (erased t: T) => Unit
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/polymorphic-erased-functions-types.scala:6:36 ---------------------------------
@@ -19,10 +19,10 @@
   |                                    Required: [T, U] => (x$1: T, x$2: U) => Unit
   |
   | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/polymorphic-erased-functions-types.scala:7:43 ---------------------------------
-7 |def t2b: [T, U] => (T, erased U) => Unit = [T, U] => (t: T, u: U) => () // error
-  |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |                                           Found:    [T, U] => (t: T, u: U) => Unit
-  |                                           Required: [T, U] => (x$1: T, erased x$2: U) => Unit
+-- [E007] Type Mismatch Error: tests/neg/polymorphic-erased-functions-types.scala:7:49 ---------------------------------
+7 |def t2b: [T, U] => (t: T, erased u: U) => Unit = [T, U] => (t: T, u: U) => () // error
+  |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |                                                 Found:    [T, U] => (t: T, u: U) => Unit
+  |                                                 Required: [T, U] => (t: T, erased u: U) => Unit
   |
   | longer explanation available when compiling with `-explain`

tests/neg/polymorphic-erased-functions-types.scala

@@ -1,7 +1,7 @@
 import language.experimental.erasedDefinitions
 
 def t1a: [T] => T => Unit = [T] => (erased t: T) => () // error
-def t1b: [T] => (erased T) => Unit = [T] => (t: T) => () // error
+def t1b: [T] => (erased t: T) => Unit = [T] => (t: T) => () // error
 
 def t2a: [T, U] => (T, U) => Unit = [T, U] => (t: T, erased u: U) => () // error
-def t2b: [T, U] => (T, erased U) => Unit = [T, U] => (t: T, u: U) => () // error
+def t2b: [T, U] => (t: T, erased u: U) => Unit = [T, U] => (t: T, u: U) => () // error

tests/run/erased-lambdas.scala

@@ -3,8 +3,8 @@
 
 // lambdas should parse and work
 
-type F = (erased Int, String) => String
-type S = (Int, erased String) => Int
+type F = (erased x: Int, y: String) => String
+type S = (x: Int, erased y: String) => Int
 
 def useF(f: F) = f(5, "a")
 def useS(f: S) = f(5, "a")
@@ -16,7 +16,7 @@ val fsExpl = (x: Int, erased y: String) => x
 
 // contextual lambdas should work
 
-type FC = (Int, erased String) ?=> Int
+type FC = (x: Int, erased y: String) ?=> Int
 
 def useCtx(f: FC) = f(using 5, "a")
 
@@ -25,7 +25,7 @@ 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
+val nested: Int => (x: String, erased y: Int) => FC = a => (_, erased _) => (c, erased d) ?=> a + c
 
 @main def Test() =
   assert("a" == useF(ff))

tests/run/polymorphic-erased-functions.scala

@@ -3,8 +3,8 @@ import language.experimental.erasedDefinitions
 object Test extends App {
 
   // Types
-  type F1 = [T] => (erased T) => Int
-  type F2 = [T, U] => (T, erased U) => T
+  type F1 = [T] => (erased x: T) => Int
+  type F2 = [T, U] => (t: T, erased u: U) => T
 
   // Terms
   val t1 = [T] => (erased t: T) => 3