Merge pull request #3449 from dotty-staging/fix-#3448

Fix #3448 Improve Type inference for IFTs

Author: odersky

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

@@ -948,11 +948,26 @@ class Definitions {
         false
     })
 
-
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
 
-  def isImplicitFunctionType(tp: Type)(implicit ctx: Context) =
-    isFunctionType(tp) && tp.dealias.typeSymbol.name.isImplicitFunction
+  /** Return underlying immplicit function type (i.e. instance of an ImplicitFunctionN class)
+   *  or NoType if none exists. The following types are considered as underlying types:
+   *   - the alias of an alias type
+   *   - the instance or origin of a TypeVar (i.e. the result of a stripTypeVar)
+   *   - the upper bound of a TypeParamRef in the current constraint
+   */
+  def asImplicitFunctionType(tp: Type)(implicit ctx: Context): Type =
+    tp.stripTypeVar.dealias match {
+      case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
+        asImplicitFunctionType(ctx.typeComparer.bounds(tp1).hiBound)
+      case tp1 =>
+        if (isFunctionType(tp1) && tp1.typeSymbol.name.isImplicitFunction) tp1
+        else NoType
+    }
+
+  /** Is `tp` an implicit function type? */
+  def isImplicitFunctionType(tp: Type)(implicit ctx: Context): Boolean =
+    asImplicitFunctionType(tp).exists
 
   // ----- primitive value class machinery ------------------------------------------
 

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

@@ -467,8 +467,8 @@ object ProtoTypes {
       case et: ExprType =>
         normalize(et.resultType, pt)
       case wtp =>
-        if (defn.isImplicitFunctionType(wtp)) normalize(wtp.dealias.argInfos.last, pt)
-        else tp
+        val iftp = defn.asImplicitFunctionType(wtp)
+        if (iftp.exists) normalize(iftp.argInfos.last, pt) else tp
     }
   }
 

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

@@ -1678,12 +1678,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           case _ => typedUnadapted(desugar(tree), pt)
         }
 
-        if (defn.isImplicitFunctionType(pt) &&
+        val ifpt = defn.asImplicitFunctionType(pt)
+        if (ifpt.exists &&
             xtree.isTerm &&
             !untpd.isImplicitClosure(xtree) &&
             !ctx.mode.is(Mode.ImplicitShadowing) &&
             !ctx.isAfterTyper)
-          makeImplicitFunction(xtree, pt)
+          makeImplicitFunction(xtree, ifpt)
         else xtree match {
           case xtree: untpd.NameTree => typedNamed(xtree, pt)
           case xtree => typedUnnamed(xtree)

tests/run/config.scala

@@ -65,12 +65,6 @@ object Test extends App {
   import Configs._
   import Exceptions._
 
-  type PC[T] = Possibly[Configured[T]]
-
-  val names: PC[List[Name]] = readName :: Nil
-  val firstNames: PC[List[String]] = names.map(_.first)
-  val longest: PC[String] = firstNames.maxBy(_.length)
-
   def readName: Configured[Possibly[Name]] = {
     val parts = config.name.split(" ")
     require(parts.length >= 2)
@@ -121,3 +115,18 @@ object OptionTest extends App {
   println(readPerson(config1))
   println(readPerson(config2))
 }
+
+object FancyStuff {
+  import Configs._
+  import Exceptions._
+  import Test._
+
+  type PC[T] = Possibly[Configured[T]]
+
+  val names: PC[List[Name]] = readName :: Nil
+  val firstNames: PC[List[String]] = names.map(_.first)
+  val longest: PC[String] = firstNames.maxBy(_.length)
+
+  val xs: List[PC[String]] = List(longest)
+  val ys: PC[List[String]] = xs.map(x => x)
+}

tests/run/i3448.scala

@@ -0,0 +1,13 @@
+object Test extends App {
+
+  case class C(x: Int)
+  type IF[T] = implicit C => T
+
+  val x: IF[Int] = implicitly[C].x
+
+  val xs0: List[IF[Int]] = List(implicit _ => x)
+  val xs: List[IF[Int]] = List(x)
+  val ys: IF[List[Int]] = xs.map(x => x)
+  val zs = ys(C(22))
+  assert(zs == List(22))
+}