Refine isFunctionType

`isFunctionType` nor returns true for dependent as well as non-dependent
function types. `isNonDepFunctionType` returns true only for the latter.

Author: odersky

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

@@ -915,17 +915,18 @@ class Definitions {
   def isProductSubType(tp: Type)(implicit ctx: Context) =
     tp.derivesFrom(ProductType.symbol)
 
-  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN? */
-  def isFunctionType(tp: Type)(implicit ctx: Context) = {
+  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN
+   *  instance?
+   */
+  def isNonDepFunctionType(tp: Type)(implicit ctx: Context) = {
     val arity = functionArity(tp)
     val sym = tp.dealias.typeSymbol
     arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction).typeSymbol)
   }
 
-  def isDependentFunctionType(tp: Type)(implicit ctx: Context) = tp.stripTypeVar match {
-    case RefinedType(parent, nme.apply, _) => isFunctionType(parent)
-    case _ => false
-  }
+  /** Is `tp` a representation of a (possibly depenent) function type or an alias of such? */
+  def isFunctionType(tp: Type)(implicit ctx: Context) =
+    isNonDepFunctionType(tp.dropDependentRefinement)
 
   // Specialized type parameters defined for scala.Function{0,1,2}.
   private lazy val Function1SpecializedParams: collection.Set[Type] =

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

@@ -1328,7 +1328,10 @@ object Types {
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)),
           mt.nonDependentResultApprox, mt.isImplicitMethod && !ctx.erasedTypes)
-        if (mt.isDependent && !mt.isImplicitMethod) RefinedType(funType, nme.apply, mt)
+        if (mt.isDependent) {
+          assert(!mt.isImplicitMethod)
+          RefinedType(funType, nme.apply, mt)
+        }
         else funType
     }
 
@@ -2590,7 +2593,7 @@ object Types {
     def integrate(tparams: List[ParamInfo], tp: Type)(implicit ctx: Context): Type =
       tparams match {
         case LambdaParam(lam, _) :: _ => tp.subst(lam, this)
-        case tparams: List[Symbol @unchecked] => tp.subst(tparams, paramRefs)
+        case params: List[Symbol @unchecked] => tp.subst(params, paramRefs)
       }
 
     final def derivedLambdaType(paramNames: List[ThisName] = this.paramNames,
@@ -2697,7 +2700,7 @@ object Types {
      *    def f(x: C)(y: x.S)       // dependencyStatus = TrueDeps
      *    def f(x: C)(y: x.T)       // dependencyStatus = FalseDeps, i.e.
      *                              // dependency can be eliminated by dealiasing.
-      */
+     */
     private def dependencyStatus(implicit ctx: Context): DependencyStatus = {
       if (myDependencyStatus != Unknown) myDependencyStatus
       else {
@@ -3220,8 +3223,10 @@ object Types {
       case _ => false
     }
 
+    protected def kindString: String
+
     override def toString =
-      try s"ParamRef($paramName)"
+      try s"${kindString}ParamRef($paramName)"
       catch {
         case ex: IndexOutOfBoundsException => s"ParamRef(<bad index: $paramNum>)"
       }
@@ -3230,8 +3235,9 @@ object Types {
   /** Only created in `binder.paramRefs`. Use `binder.paramRefs(paramNum)` to
    *  refer to `TermParamRef(binder, paramNum)`.
    */
-  abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef {
+  abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef with SingletonType {
     type BT = TermLambda
+    def kindString = "Term"
     def copyBoundType(bt: BT) = bt.paramRefs(paramNum)
   }
 
@@ -3240,6 +3246,7 @@ object Types {
    */
   abstract case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
     type BT = TypeLambda
+    def kindString = "Type"
     def copyBoundType(bt: BT) = bt.paramRefs(paramNum)
 
     /** Looking only at the structure of `bound`, is one of the following true?

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

@@ -684,7 +684,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   private def decomposeProtoFunction(pt: Type, defaultArity: Int)(implicit ctx: Context): (List[Type], Type) = pt match {
-    case _ if defn.isFunctionType(pt) =>
+    case _ if defn.isNonDepFunctionType(pt) =>
       // if expected parameter type(s) are wildcards, approximate from below.
       // if expected result type is a wildcard, approximate from above.
       // this can type the greatest set of admissible closures.
@@ -895,7 +895,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           case mt: MethodType =>
             pt match {
               case SAMType(meth)
-              if !defn.isFunctionType(pt.dealias.dropDependentRefinement) && mt <:< meth.info =>
+              if !defn.isFunctionType(pt) && mt <:< meth.info =>
                 if (!isFullyDefined(pt, ForceDegree.all))
                   ctx.error(ex"result type of closure is an underspecified SAM type $pt", tree.pos)
                 TypeTree(pt)

tests/pos/depfuntype.scala

@@ -13,6 +13,6 @@ object Test {
   val depfun3: DF = depfun2
 
   val d: C = c
-  val z = depfun1(d)
+  val z = depfun3(d)
   val z1: d.M = z
 }