Refactor function operations in Definitions

Also: show implicit function types correctly.

Also: refine applications of implicit funcitons

 - don't do it for closure trees
 - don't do it after typer.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -501,12 +501,14 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    */
   object closure {
     def unapply(tree: Tree): Option[(List[Tree], Tree, Tree)] = tree match {
-      case Block(_, Closure(env, meth, tpt)) => Some(env, meth, tpt)
+      case Block(_, expr) => unapply(expr)
       case Closure(env, meth, tpt) => Some(env, meth, tpt)
       case _ => None
     }
   }
 
+  def isClosure(tree: Tree) = closure.unapply(tree).isDefined
+
   /** If tree is a closure, its body, otherwise tree itself */
   def closureBody(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, Closure(_, _, _)) => meth.rhs

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

@@ -617,15 +617,16 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type)(implicit ctx: Context) =
-      FunctionType(args.length).appliedTo(args ::: resultType :: Nil)
+    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) =
+      FunctionType(args.length, isImplicit).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context) = {
       val tsym = ft.typeSymbol
-      if (isFunctionClass(tsym)) {
-        lazy val targs = ft.argInfos
+      val isImplicitFun = isImplicitFunctionClass(tsym)
+      if (isImplicitFun || isFunctionClass(tsym)) {
+        val targs = ft.argInfos
         val numArgs = targs.length - 1
-        if (numArgs >= 0 && FunctionType(numArgs).symbol == tsym)
-          Some(targs.init, targs.last)
+        if (numArgs >= 0 && FunctionType(numArgs, isImplicitFun).symbol == tsym)
+          Some(targs.init, targs.last, isImplicitFun)
         else None
       }
       else None
@@ -689,8 +690,9 @@ class Definitions {
   def ImplicitFunctionClass(n: Int)(implicit ctx: Context) =
     ctx.requiredClass("scala.ImplicitFunction" + n.toString)
 
-  def FunctionType(n: Int)(implicit ctx: Context): TypeRef =
-    if (n < MaxImplementedFunctionArity) ImplementedFunctionType(n)
+  def FunctionType(n: Int, isImplicit: Boolean = false)(implicit ctx: Context): TypeRef =
+    if (isImplicit && !ctx.erasedTypes) ImplicitFunctionClass(n).typeRef
+    else if (n < MaxImplementedFunctionArity) ImplementedFunctionType(n)
     else FunctionClass(n).typeRef
 
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
@@ -766,11 +768,15 @@ class Definitions {
   def isProductSubType(tp: Type)(implicit ctx: Context) =
     (tp derivesFrom ProductType.symbol) && tp.baseClasses.exists(isProductClass)
 
-  def isFunctionType(tp: Type)(implicit ctx: Context) =
-    isFunctionClass(tp.dealias.typeSymbol) && {
-      val arity = functionArity(tp)
-      arity >= 0 && tp.isRef(FunctionType(functionArity(tp)).typeSymbol)
-    }
+  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN ? */
+  def isFunctionType(tp: Type)(implicit ctx: Context) = {
+    val arity = functionArity(tp)
+    val sym = tp.dealias.typeSymbol
+    arity >= 0 && (
+      isFunctionClass(sym) && tp.isRef(FunctionType(arity, isImplicit = false).typeSymbol) ||
+      isImplicitFunctionClass(sym) && tp.isRef(FunctionType(arity, isImplicit = true).typeSymbol)
+    )
+  }
 
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -113,20 +113,21 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   override def toText(tp: Type): Text = controlled {
     def toTextTuple(args: List[Type]): Text =
       "(" ~ Text(args.map(argText), ", ") ~ ")"
-    def toTextFunction(args: List[Type]): Text =
+    def toTextFunction(args: List[Type], isImplicit: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
           if (args.length == 2 && !defn.isTupleType(args.head))
             atPrec(InfixPrec) { argText(args.head) }
           else
             toTextTuple(args.init)
-        argStr ~ " => " ~ argText(args.last)
+        ("implicit " provided isImplicit) ~ argStr ~ " => " ~ argText(args.last)
       }
     homogenize(tp) match {
       case AppliedType(tycon, args) =>
         val cls = tycon.typeSymbol
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
-        if (defn.isFunctionClass(cls)) return toTextFunction(args)
+        if (defn.isFunctionClass(cls)) return toTextFunction(args, isImplicit = false)
+        if (defn.isImplicitFunctionClass(cls)) return toTextFunction(args, isImplicit = true)
         if (defn.isTupleClass(cls)) return toTextTuple(args)
         return (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close
       case tp: TypeRef =>

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

@@ -1231,7 +1231,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         val alts1 = alts filter pt.isMatchedBy
         resolveOverloaded(alts1, pt1, targs1)
 
-      case defn.FunctionOf(args, resultType) =>
+      case defn.FunctionOf(args, resultType, _) =>
         narrowByTypes(alts, args, resultType)
 
       case pt =>
@@ -1282,7 +1282,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             //   (p_1_1, ..., p_m_1) => r_1
             //   ...
             //   (p_1_n, ..., p_m_n) => r_n
-            val decomposedFormalsForArg: List[Option[(List[Type], Type)]] =
+            val decomposedFormalsForArg: List[Option[(List[Type], Type, Boolean)]] =
               formalsForArg.map(defn.FunctionOf.unapply)
             if (decomposedFormalsForArg.forall(_.isDefined)) {
               val formalParamTypessForArg: List[List[Type]] =

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

@@ -1876,8 +1876,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           missingArgs
       case wtp: RefinedType
       if defn.isImplicitFunctionClass(wtp.underlyingClassRef(refinementOK = false).classSymbol) &&
-         !isApplyProto(pt) =>
-        typr.println(i"insert apply on implicit $tree")
+         !isClosure(tree) &&
+         !isApplyProto(pt) &&
+         !ctx.isAfterTyper =>
+        typr.println("insert apply on implicit $tree")
         typed(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt)
       case _ =>
         ctx.typeComparer.GADTused = false