Handle dependent function types in Typer

Author: odersky

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

@@ -130,6 +130,9 @@ trait Symbols { this: Context =>
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
   }
 
+  def newRefinedClassSymbol = newCompleteClassSymbol(
+    ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil)
+
   /** Create a module symbol with associated module class
    *  from its non-info fields and a function producing the info
    *  of the module class (this info may be lazy).

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

@@ -2723,6 +2723,20 @@ object Types {
     def isParamDependent(implicit ctx: Context): Boolean = paramDependencyStatus == TrueDeps
 
     def newParamRef(n: Int) = new TermParamRef(this, n) {}
+
+    /** The least supertype of `resultType` that does not contain parameter dependencies */
+    def nonDependentResultApprox(implicit ctx: Context): Type =
+      if (isDependent) {
+        val dropDependencies = new ApproximatingTypeMap {
+          def apply(tp: Type) = tp match {
+            case tp @ TermParamRef(thisLambdaType, _) =>
+              range(tp.bottomType, atVariance(1)(apply(tp.underlying)))
+            case _ => mapOver(tp)
+          }
+        }
+        dropDependencies(resultType)
+      }
+      else resultType
   }
 
   abstract case class MethodType(paramNames: List[TermName])(

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -999,8 +999,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
               val argPats = until(end)(readTerm())
               UnApply(fn, implicitArgs, argPats, patType)
             case REFINEDtpt =>
-              val refineCls = ctx.newCompleteClassSymbol(
-                ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil)
+              val refineCls = ctx.newRefinedClassSymbol
               typeAtAddr(start) = refineCls.typeRef
               val parent = readTpt()
               val refinements = readStats(refineCls, end)(localContext(refineCls))

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

@@ -697,160 +697,190 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") {
+    if (ctx.mode is Mode.Type) typedFunctionType(tree, pt)
+    else typedFunctionValue(tree, pt)
+  }
+
+  def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
     val untpd.Function(args, body) = tree
-    if (ctx.mode is Mode.Type) {
-      val isImplicit = tree match {
-        case _: untpd.ImplicitFunction =>
-          if (args.length == 0) {
-            ctx.error(ImplicitFunctionTypeNeedsNonEmptyParameterList(), tree.pos)
-            false
-          }
-          else true
-        case _ => false
-      }
-      val funCls = defn.FunctionClass(args.length, isImplicit)
-      typed(cpy.AppliedTypeTree(tree)(
-        untpd.TypeTree(funCls.typeRef), args :+ body), pt)
+    val isImplicit = tree match {
+      case _: untpd.ImplicitFunction =>
+        if (args.length == 0) {
+          ctx.error(ImplicitFunctionTypeNeedsNonEmptyParameterList(), tree.pos)
+          false
+        }
+        else true
+      case _ => false
     }
-    else {
-      val params = args.asInstanceOf[List[untpd.ValDef]]
-
-      pt match {
-        case pt: TypeVar if untpd.isFunctionWithUnknownParamType(tree) =>
-          // try to instantiate `pt` if this is possible. If it does not
-          // work the error will be reported later in `inferredParam`,
-          // when we try to infer the parameter type.
-          isFullyDefined(pt, ForceDegree.noBottom)
-        case _ =>
-      }
+    val funCls = defn.FunctionClass(args.length, isImplicit)
+
+    def typedDependent(params: List[ValDef])(implicit ctx: Context) = {
+      completeParams(params)
+      val params1 = params.map(typedExpr(_).asInstanceOf[ValDef])
+      val resultTpt = typed(body)
+      val companion = if (isImplicit) ImplicitMethodType else MethodType
+      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")
+      val resTpt = TypeTree(mt.nonDependentResultApprox).withPos(body.pos)
+      val typeArgs = params1.map(_.tpt) :+ resTpt
+      val tycon = TypeTree(funCls.typeRef)
+      val core = assignType(cpy.AppliedTypeTree(tree)(tycon, typeArgs), tycon, typeArgs)
+      val appMeth = ctx.newSymbol(ctx.owner, nme.apply, Synthetic | Deferred, mt)
+      val appDef = assignType(
+        untpd.DefDef(appMeth.name, Nil, List(params1), resultTpt, EmptyTree),
+        appMeth)
+      RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
+    }
+
+    args match {
+      case ValDef(_, _, _) :: _ =>
+        typedDependent(args.asInstanceOf[List[ValDef]])(
+          ctx.fresh.setOwner(ctx.newRefinedClassSymbol).setNewScope)
+      case _ =>
+        typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funCls.typeRef), args :+ body), pt)
+    }
+  }
 
-      val (protoFormals, protoResult) = decomposeProtoFunction(pt, params.length)
+  def typedFunctionValue(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
+    val untpd.Function(args, body) = tree
+    val params = args.asInstanceOf[List[untpd.ValDef]]
 
-      def refersTo(arg: untpd.Tree, param: untpd.ValDef): Boolean = arg match {
-        case Ident(name) => name == param.name
-        case _ => false
-      }
+    pt match {
+      case pt: TypeVar if untpd.isFunctionWithUnknownParamType(tree) =>
+        // try to instantiate `pt` if this is possible. If it does not
+        // work the error will be reported later in `inferredParam`,
+        // when we try to infer the parameter type.
+        isFullyDefined(pt, ForceDegree.noBottom)
+      case _ =>
+    }
 
-      /** The function body to be returned in the closure. Can become a TypedSplice
-       *  of a typed expression if this is necessary to infer a parameter type.
-       */
-      var fnBody = tree.body
+    val (protoFormals, protoResult) = decomposeProtoFunction(pt, params.length)
 
-      /** A map from parameter names to unique positions where the parameter
-       *  appears in the argument list of an application.
-       */
-      var paramIndex = Map[Name, Int]()
+    def refersTo(arg: untpd.Tree, param: untpd.ValDef): Boolean = arg match {
+      case Ident(name) => name == param.name
+      case _ => false
+    }
 
-      /** If parameter `param` appears exactly once as an argument in `args`,
-       *  the singleton list consisting of its position in `args`, otherwise `Nil`.
-       */
-      def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] = {
-        def loop(args: List[untpd.Tree], start: Int): List[Int] = args match {
-          case arg :: args1 =>
-            val others = loop(args1, start + 1)
-            if (refersTo(arg, param)) start :: others else others
-          case _ => Nil
-        }
-        val allIndices = loop(args, 0)
-        if (allIndices.length == 1) allIndices else Nil
+    /** The function body to be returned in the closure. Can become a TypedSplice
+      *  of a typed expression if this is necessary to infer a parameter type.
+      */
+    var fnBody = tree.body
+
+    /** A map from parameter names to unique positions where the parameter
+      *  appears in the argument list of an application.
+      */
+    var paramIndex = Map[Name, Int]()
+
+    /** If parameter `param` appears exactly once as an argument in `args`,
+      *  the singleton list consisting of its position in `args`, otherwise `Nil`.
+      */
+    def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] = {
+      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match {
+        case arg :: args1 =>
+          val others = loop(args1, start + 1)
+          if (refersTo(arg, param)) start :: others else others
+        case _ => Nil
       }
+      val allIndices = loop(args, 0)
+      if (allIndices.length == 1) allIndices else Nil
+    }
 
-      /** If function is of the form
-       *      (x1, ..., xN) => f(... x1, ..., XN, ...)
-       *  where each `xi` occurs exactly once in the argument list of `f` (in
-       *  any order), the type of `f`, otherwise NoType.
-       *  Updates `fnBody` and `paramIndex` as a side effect.
-       *  @post: If result exists, `paramIndex` is defined for the name of
-       *         every parameter in `params`.
-       */
-      def calleeType: Type = fnBody match {
-        case Apply(expr, args) =>
-          paramIndex = {
-            for (param <- params; idx <- paramIndices(param, args))
-            yield param.name -> idx
-          }.toMap
-          if (paramIndex.size == params.length)
-            expr match {
-              case untpd.TypedSplice(expr1) =>
-                expr1.tpe
-              case _ =>
-                val protoArgs = args map (_ withType WildcardType)
-                val callProto = FunProto(protoArgs, WildcardType, this)
-                val expr1 = typedExpr(expr, callProto)
-                fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
-                expr1.tpe
-            }
-          else NoType
+    /** If function is of the form
+      *      (x1, ..., xN) => f(... x1, ..., XN, ...)
+      *  where each `xi` occurs exactly once in the argument list of `f` (in
+      *  any order), the type of `f`, otherwise NoType.
+      *  Updates `fnBody` and `paramIndex` as a side effect.
+      *  @post: If result exists, `paramIndex` is defined for the name of
+      *         every parameter in `params`.
+      */
+    def calleeType: Type = fnBody match {
+      case Apply(expr, args) =>
+        paramIndex = {
+          for (param <- params; idx <- paramIndices(param, args))
+          yield param.name -> idx
+        }.toMap
+        if (paramIndex.size == params.length)
+          expr match {
+            case untpd.TypedSplice(expr1) =>
+              expr1.tpe
+            case _ =>
+              val protoArgs = args map (_ withType WildcardType)
+              val callProto = FunProto(protoArgs, WildcardType, this)
+              val expr1 = typedExpr(expr, callProto)
+              fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
+              expr1.tpe
+          }
+        else NoType
+      case _ =>
+        NoType
+    }
+
+    /** Two attempts: First, if expected type is fully defined pick this one.
+      *  Second, if function is of the form
+      *      (x1, ..., xN) => f(... x1, ..., XN, ...)
+      *  where each `xi` occurs exactly once in the argument list of `f` (in
+      *  any order), and f has a method type MT, pick the corresponding parameter
+      *  type in MT, if this one is fully defined.
+      *  If both attempts fail, issue a "missing parameter type" error.
+      */
+    def inferredParamType(param: untpd.ValDef, formal: Type): Type = {
+      if (isFullyDefined(formal, ForceDegree.noBottom)) return formal
+      calleeType.widen match {
+        case mtpe: MethodType =>
+          val pos = paramIndex(param.name)
+          if (pos < mtpe.paramInfos.length) {
+            val ptype = mtpe.paramInfos(pos)
+            if (isFullyDefined(ptype, ForceDegree.noBottom) && !ptype.isRepeatedParam)
+              return ptype
+          }
         case _ =>
-          NoType
       }
+      errorType(AnonymousFunctionMissingParamType(param, args, tree, pt), param.pos)
+    }
 
-      /** Two attempts: First, if expected type is fully defined pick this one.
-       *  Second, if function is of the form
-       *      (x1, ..., xN) => f(... x1, ..., XN, ...)
-       *  where each `xi` occurs exactly once in the argument list of `f` (in
-       *  any order), and f has a method type MT, pick the corresponding parameter
-       *  type in MT, if this one is fully defined.
-       *  If both attempts fail, issue a "missing parameter type" error.
-       */
-      def inferredParamType(param: untpd.ValDef, formal: Type): Type = {
-        if (isFullyDefined(formal, ForceDegree.noBottom)) return formal
-        calleeType.widen match {
-          case mtpe: MethodType =>
-            val pos = paramIndex(param.name)
-            if (pos < mtpe.paramInfos.length) {
-              val ptype = mtpe.paramInfos(pos)
-              if (isFullyDefined(ptype, ForceDegree.noBottom) && !ptype.isRepeatedParam)
-                return ptype
-            }
-          case _ =>
-        }
-        errorType(AnonymousFunctionMissingParamType(param, args, tree, pt), param.pos)
-      }
+    def protoFormal(i: Int): Type =
+      if (protoFormals.length == params.length) protoFormals(i)
+      else errorType(WrongNumberOfParameters(protoFormals.length), tree.pos)
 
-      def protoFormal(i: Int): Type =
-        if (protoFormals.length == params.length) protoFormals(i)
-        else errorType(WrongNumberOfParameters(protoFormals.length), tree.pos)
-
-      /** Is `formal` a product type which is elementwise compatible with `params`? */
-      def ptIsCorrectProduct(formal: Type) = {
-        isFullyDefined(formal, ForceDegree.noBottom) &&
-        defn.isProductSubType(formal) &&
-        Applications.productSelectorTypes(formal).corresponds(params) {
-          (argType, param) =>
-            param.tpt.isEmpty || argType <:< typedAheadType(param.tpt).tpe
-        }
+    /** Is `formal` a product type which is elementwise compatible with `params`? */
+    def ptIsCorrectProduct(formal: Type) = {
+      isFullyDefined(formal, ForceDegree.noBottom) &&
+      defn.isProductSubType(formal) &&
+      Applications.productSelectorTypes(formal).corresponds(params) {
+        (argType, param) =>
+          param.tpt.isEmpty || argType <:< typedAheadType(param.tpt).tpe
       }
+    }
 
-      val desugared =
-        if (protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head)) {
-          desugar.makeTupledFunction(params, fnBody)
-        }
-        else {
-          val inferredParams: List[untpd.ValDef] =
-            for ((param, i) <- params.zipWithIndex) yield
-              if (!param.tpt.isEmpty) param
-              else cpy.ValDef(param)(
-                tpt = untpd.TypeTree(
-                  inferredParamType(param, protoFormal(i)).underlyingIfRepeated(isJava = false)))
-
-          // Define result type of closure as the expected type, thereby pushing
-          // down any implicit searches. We do this even if the expected type is not fully
-          // defined, which is a bit of a hack. But it's needed to make the following work
-          // (see typers.scala and printers/PlainPrinter.scala for examples).
-          //
-          //     def double(x: Char): String = s"$x$x"
-          //     "abc" flatMap double
-          //
-          val resultTpt = protoResult match {
-            case WildcardType(_) => untpd.TypeTree()
-            case _ => untpd.TypeTree(protoResult)
-          }
-          val inlineable = pt.hasAnnotation(defn.InlineParamAnnot)
-          desugar.makeClosure(inferredParams, fnBody, resultTpt, inlineable)
+    val desugared =
+      if (protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head)) {
+        desugar.makeTupledFunction(params, fnBody)
+      }
+      else {
+        val inferredParams: List[untpd.ValDef] =
+          for ((param, i) <- params.zipWithIndex) yield
+            if (!param.tpt.isEmpty) param
+            else cpy.ValDef(param)(
+              tpt = untpd.TypeTree(
+                inferredParamType(param, protoFormal(i)).underlyingIfRepeated(isJava = false)))
+
+        // Define result type of closure as the expected type, thereby pushing
+        // down any implicit searches. We do this even if the expected type is not fully
+        // defined, which is a bit of a hack. But it's needed to make the following work
+        // (see typers.scala and printers/PlainPrinter.scala for examples).
+        //
+        //     def double(x: Char): String = s"$x$x"
+        //     "abc" flatMap double
+        //
+        val resultTpt = protoResult match {
+          case WildcardType(_) => untpd.TypeTree()
+          case _ => untpd.TypeTree(protoResult)
         }
-      typed(desugared, pt)
-    }
+        val inlineable = pt.hasAnnotation(defn.InlineParamAnnot)
+        desugar.makeClosure(inferredParams, fnBody, resultTpt, inlineable)
+      }
+    typed(desugared, pt)
   }
 
   def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = track("typedClosure") {

tests/neg/depfuns.scala

@@ -0,0 +1,5 @@
+object Test {
+
+  type T = (x: Int) // error: `=>' expected
+
+}

tests/pos/depfuntype.scala

@@ -0,0 +1,14 @@
+object Test {
+
+  trait C { type M; val m: M }
+
+  type DF = (x: C) => x.M
+  val depfun: DF = ??? // (x: C) => x.m
+  val c = new C { type M = Int; val m = 0 }
+  val y = depfun(c)
+  val y1: Int = y
+
+  val d: C = c
+  val z = depfun(d)
+  val z1: d.M = z
+}