Rewrite FunctionOf to deal with erased parameters

`apply` and `unapply` now returns and consumes a list of erased parameter
flags, just like other function/method constructing functions.

Author: natsukagami

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

@@ -254,12 +254,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           // If `isParamDependent == false`, the value of `previousParamRefs` is not used.
           if isParamDependent then mutable.ListBuffer[TermRef]() else (null: ListBuffer[TermRef] | Null).uncheckedNN
 
-        def valueParam(name: TermName, origInfo: Type): TermSymbol =
+        def valueParam(name: TermName, origInfo: Type, isErased: Boolean): TermSymbol =
           val maybeImplicit =
             if tp.isContextualMethod then Given
             else if tp.isImplicitMethod then Implicit
             else EmptyFlags
-          val maybeErased = if tp.isErasedMethod then Erased else EmptyFlags // TODO @natsukagami change this
+          val maybeErased = if isErased then Erased else EmptyFlags
 
           def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
 
@@ -270,14 +270,18 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           else makeSym(origInfo)
         end valueParam
 
+        val erasedParams = if tp.isErasedMethod
+                             then tp.companion.asInstanceOf[ErasedMethodCompanion].isErased
+                             else List.fill(tp.paramNames.size) { false }
+
         val (vparams: List[TermSymbol], remaining1) =
           if tp.paramNames.isEmpty then (Nil, remaining)
           else remaining match
             case vparams :: remaining1 =>
               assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
               (vparams.asInstanceOf[List[TermSymbol]], remaining1)
             case nil =>
-              (tp.paramNames.lazyZip(tp.paramInfos).map(valueParam), Nil)
+              (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(erasedParams).map(valueParam), Nil)
         val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
         (rtp, vparams :: paramss)
       case _ =>

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -611,9 +611,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       //println(i"check conforms $actual1 <<< $expected1")
       super.checkConformsExpr(actual1, expected1, tree)
 
-    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, isErased: Boolean)(using Context): Type =
-      val erasedParams = args.map(_ => isErased) // TODO @natsukagami fix
-      MethodType.companion(isContextual = isContextual, isErased = erasedParams)(args, resultType)
+    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, isErased: List[Boolean])(using Context): Type =
+      MethodType.companion(isContextual = isContextual, isErased = isErased)(args, resultType)
         .toFunctionType(isJava = false, alwaysDependent = true)
 
     /** Turn `expected` into a dependent function when `actual` is dependent. */

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -35,11 +35,9 @@ extends tpd.TreeTraverser:
    *  arguments `argTypes` and result `resType`.
    */
   private def depFun(tycon: Type, argTypes: List[Type], resType: Type)(using Context): Type =
-    assert(!defn.isErasedFunctionType(tycon)) // TODO @natsukagami not sure how to know
-                                                           // erased parameter info here.
     MethodType.companion(
         isContextual = defn.isContextFunctionClass(tycon.classSymbol),
-        isErased = List()
+        isErased = defn.erasedFunctionParameters(tycon)
       )(argTypes, resType)
       .toFunctionType(isJava = false, alwaysDependent = true)
 
@@ -256,7 +254,7 @@ extends tpd.TreeTraverser:
   private def expandThrowsAlias(tp: Type)(using Context) = tp match
     case AppliedType(tycon, res :: exc :: Nil) if tycon.typeSymbol == defn.throwsAlias =>
       // hard-coded expansion since $throws aliases in stdlib are defined with `?=>` rather than `?->`
-      defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true, isErased = true)
+      defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true, isErased = List(true))
     case _ => tp
 
   private def expandThrowsAliases(using Context) = new TypeMap:

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

@@ -1086,14 +1086,23 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, isErased: Boolean = false)(using Context): Type =
-      FunctionType(args.length, isContextual, isErased).appliedTo(args ::: resultType :: Nil)
-    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, Boolean)] = {
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, isErased: List[Boolean] = List())(using Context): Type =
+      assert(isErased.size == 0 || args.size == isErased.size)
+      val erasedParams = isErased.padTo(args.size, false)
+      val isErasedFn = erasedParams.contains(true)
+      val fnType =
+        FunctionType(args.length, isContextual, isErased = isErasedFn).appliedTo(args ::: resultType :: Nil)
+      if isErasedFn then
+        val mt = MethodType.companion(isContextual, false, isErased)(args, resultType)
+        RefinedType(fnType, nme.apply, mt)
+      else fnType
+    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, List[Boolean])] = {
       val tsym = ft.typeSymbol
       if isFunctionClass(tsym) && ft.isRef(tsym) then
         val targs = ft.dealias.argInfos
+        val isErased = erasedFunctionParameters(ft)
         if (targs.isEmpty) None
-        else Some(targs.init, targs.last, tsym.name.isContextFunction, tsym.name.isErasedFunction)
+        else Some(targs.init, targs.last, tsym.name.isContextFunction, isErased)
       else None
     }
   }
@@ -1503,9 +1512,12 @@ class Definitions {
 
   /** Is an erased function class.
    *   - ErasedFunctionN for N > 0
-   *   - ErasedContextFunctionN for N > 0
+   *
+   * This should not be used for checking if a type is an erased function type. Use `isErasedFunctionType`.
+   * Only helpful if you have a `RefinedType(parent, nme.apply, mt)` and
+   * want to check if `parent` is an erased function class.
    */
-  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction // TODO @natsukagami fix this
+  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction
 
   /** Is either FunctionXXL or  a class that will be erased to FunctionXXL
    *   - FunctionXXL
@@ -1804,9 +1816,18 @@ class Definitions {
         val tp1 = asContextFunctionType(tp)
         if tp1.exists then
           val args = tp1.dropDependentRefinement.argInfos
-          Some((args.init, args.last, List(tp1.typeSymbol.name.isErasedFunction))) // TODO @natsukagami fix this
+          val isErased = erasedFunctionParameters(tp1)
+          Some((args.init, args.last, isErased))
         else None
 
+  /* Returns a list of erased booleans marking whether parameters are erased, for a function type. */
+  def erasedFunctionParameters(tp: Type)(using Context): List[Boolean] = tp.dealias match {
+    case RefinedType(parent, nme.apply, mt) if defn.isErasedFunctionType(parent) =>
+      mt.asInstanceOf[MethodType].companion.asInstanceOf[ErasedMethodCompanion].isErased
+    case tp if isFunctionType(tp) => List.fill(functionArity(tp)) { false }
+    case _ => List()
+  }
+
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
     tp.derivesFrom(defn.ErasedFunctionClass)
 

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

@@ -208,7 +208,6 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        
         skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
         && found
       }

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

@@ -1839,15 +1839,20 @@ object Types {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
         val isContextual = mt.isContextualMethod && !ctx.erasedTypes
-        val isErased = mt.isErasedMethod && !ctx.erasedTypes // TODO @natsukagami fix this
+        val isErased =
+          (if mt.isErasedMethod && !ctx.erasedTypes then
+            mt.companion.asInstanceOf[ErasedMethodCompanion].isErased
+          else List.fill(mt.paramInfos.size) { false }) dropRight dropLast
+          // println(s"$mt => $isErased")
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType(isJava)
           case res => res
         }
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
           result1, isContextual, isErased)
-        if alwaysDependent || isErased || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
+        if alwaysDependent || mt.isResultDependent then
+          RefinedType(funType, nme.apply, mt)
         else funType
     }
 

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

@@ -110,7 +110,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         def functionTypeEqual(baseFun: Type, actualArgs: List[Type],
             actualRet: Type, expected: Type) =
           expected =:= defn.FunctionOf(actualArgs, actualRet,
-            defn.isContextFunctionType(baseFun), defn.isErasedFunctionType(baseFun))
+            defn.isContextFunctionType(baseFun), defn.erasedFunctionParameters(baseFun))
         val arity: Int =
           if defn.isErasedFunctionType(fun) || defn.isErasedFunctionType(fun) then -1 // TODO support?
           else if defn.isFunctionType(fun) then

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

@@ -1554,7 +1554,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                         |because it has internal parameter dependencies""")
                 else if ((tree.tpt `eq` untpd.ContextualEmptyTree) && mt.paramNames.isEmpty)
                   // Note implicitness of function in target type since there are no method parameters that indicate it.
-                  TypeTree(defn.FunctionOf(Nil, mt.resType, isContextual = true, isErased = false))
+                  TypeTree(defn.FunctionOf(Nil, mt.resType, isContextual = true, isErased = List()))
                 else
                   EmptyTree
             }