Fix dependent function type building

Need to record function modifiers in parameters, or they will get
lost in pickling. Fixes failing pickling test pos/depfuntype.scala.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -757,26 +757,27 @@ class Typer extends Namer
 
   def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.Function(args, body) = tree
-    val (isContextual, isErased) = tree match {
-      case tree: untpd.FunctionWithMods =>
-        val isContextual = tree.mods.is(Contextual)
-        var isErased = tree.mods.is(Erased)
-        if (isErased && args.isEmpty) {
-          ctx.error("An empty function cannot not be erased", tree.pos)
-          isErased = false
-        }
-        (isContextual, isErased)
-      case _ => (false, false)
+    var funFlags = tree match {
+      case tree: untpd.FunctionWithMods => tree.mods.flags
+      case _ => EmptyFlags
+    }
+    if (funFlags.is(Erased) && args.isEmpty) {
+      ctx.error("An empty function cannot not be erased", tree.pos)
+      funFlags = funFlags &~ Erased
     }
 
-    val funCls = defn.FunctionClass(args.length, isContextual, isErased)
+    val funCls = defn.FunctionClass(args.length,
+        isContextual = funFlags.is(Contextual), isErased = funFlags.is(Erased))
 
     /** Typechecks dependent function type with given parameters `params` */
     def typedDependent(params: List[ValDef])(implicit ctx: Context): Tree = {
       completeParams(params)
       val params1 = params.map(typedExpr(_).asInstanceOf[ValDef])
+      if (!funFlags.isEmpty)
+        params1.foreach(_.symbol.setFlag(funFlags))
       val resultTpt = typed(body)
-      val companion = MethodType.maker(isContextual = isContextual, isErased = isErased)
+      val companion = MethodType.maker(
+          isContextual = funFlags.is(Contextual), isErased = funFlags.is(Erased))
       val mt = companion.fromSymbols(params1.map(_.symbol), resultTpt.tpe)
       if (mt.isParamDependent)
         ctx.error(i"$mt is an illegal function type because it has inter-parameter dependencies", tree.pos)
@@ -2271,6 +2272,7 @@ class Typer extends Namer
 
       def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
         case wtp: MethodOrPoly =>
+          def methodStr = methPart(tree).symbol.showLocated
           if (matchingApply(wtp, pt))
             if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
               adapt(tree, pt.tupled, locked)
@@ -2279,7 +2281,7 @@ class Typer extends Namer
           else if (wtp.isContextual)
             adaptNoArgs(wtp)  // insert arguments implicitly
           else
-            errorTree(tree, em"Missing arguments for ${methPart(tree).symbol.showLocated}")
+            errorTree(tree, em"Missing arguments for $methodStr")
         case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
           errorTree(tree, MethodDoesNotTakeParameters(tree))
         }

compiler/test-resources/repl/3932

@@ -1,2 +1,2 @@
-scala> def fun[T](x: T): implicit List[T] => Int = ???
-def fun[T](x: T): implicit List[T] => Int
+scala> def fun[T](x: T): List[T] |=> Int = ???
+def fun[T](x: T): List[T] |=> Int