Address reviewers comments

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1014,10 +1014,10 @@ object Types {
       case _ => this
     }
 
-    /** If this is a dependent function type, drop the `apply` refinement */
-    final def dropDependentRefinement(implicit ctx: Context): Type = stripTypeVar match {
+    /** Dealias, and if result is a dependent function type, drop the `apply` refinement. */
+    final def dropDependentRefinement(implicit ctx: Context): Type = dealias match {
       case RefinedType(parent, nme.apply, _) => parent
-      case _ => this
+      case tp => tp
     }
 
     /** The type constructor of an applied type, otherwise the type itself */

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

@@ -54,7 +54,7 @@ object Inferencing {
    */
   def instantiateDependent(tp: Type, tparams: List[Symbol], vparamss: List[List[Symbol]])(implicit ctx: Context): Unit = {
     val dependentVars = new TypeAccumulator[Set[TypeVar]] {
-      lazy val params = (vparamss :\ tparams)( _ ::: _)
+      lazy val params = (tparams :: vparamss).flatten
       def apply(tvars: Set[TypeVar], tp: Type) = tp match {
         case tp: TypeVar
         if !tp.isInstantiated &&

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

@@ -715,7 +715,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     val funCls = defn.FunctionClass(args.length, isImplicit)
 
-    def typedDependent(params: List[ValDef])(implicit ctx: Context) = {
+    /** 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])
       val resultTpt = typed(body)
@@ -744,8 +745,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedFunctionValue(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
-    val untpd.Function(args, body) = tree
-    val params = args.asInstanceOf[List[untpd.ValDef]]
+    val untpd.Function(params: List[untpd.ValDef], body) = tree
 
     pt match {
       case pt: TypeVar if untpd.isFunctionWithUnknownParamType(tree) =>
@@ -837,7 +837,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           }
         case _ =>
       }
-      errorType(AnonymousFunctionMissingParamType(param, args, tree, pt), param.pos)
+      errorType(AnonymousFunctionMissingParamType(param, params, tree, pt), param.pos)
     }
 
     def protoFormal(i: Int): Type =
@@ -1721,7 +1721,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   protected def makeImplicitFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
-    val defn.FunctionOf(formals, _, true) = pt.dealias.dropDependentRefinement
+    val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement
     val paramTypes = formals.map(fullyDefinedType(_, "implicit function parameter", tree.pos))
     val ifun = desugar.makeImplicitFunction(paramTypes, tree)
     typr.println(i"make implicit function $tree / $pt ---> $ifun")