Properly desugar implicit/erased dependent function types

In `typedDependent` we used to desugar the type `implicit (x: HasT) => x.T` to:

     ImplicitFunction1[HasT, HasT#T] { def apply(x: HasT): x.T }

This commit sets the implicit/erased modifiers on all parameters of an
implicit/erased function type, this changes the desugaring to the more correct:

     ImplicitFunction1[HasT, HasT#T] { def apply(implicit x: HasT): x.T }

Author: smarter

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

@@ -759,8 +759,8 @@ object Parsers {
               case Ident(name) if name != tpnme.WILDCARD && in.token == COLON =>
                 isValParamList = true
                 funArgTypesRest(
-                    typedFunParam(paramStart, name.toTermName),
-                    () => typedFunParam(in.offset, ident()))
+                    typedFunParam(paramStart, name.toTermName, imods),
+                    () => typedFunParam(in.offset, ident(), imods))
               case t =>
                 funArgTypesRest(t, funArgType)
             }
@@ -800,9 +800,9 @@ object Parsers {
     }
 
     /** TypedFunParam   ::= id ':' Type */
-    def typedFunParam(start: Offset, name: TermName): Tree = atPos(start) {
+    def typedFunParam(start: Offset, name: TermName, mods: Modifiers = EmptyModifiers): Tree = atPos(start) {
       accept(COLON)
-      makeParameter(name, typ(), Modifiers(Param))
+      makeParameter(name, typ(), mods | Param)
     }
 
     /** InfixType ::= RefinedType {id [nl] refinedType}