Implement individual erased parameters

Breaking change for erasedDefinitions: this effectively makes the
current `erased` marker in parameter list apply to only the first
parameter.

    def f(erased a: int, b: int)

should now be written as

    def f(erased a: int, erased b: int)

    type Function1 = (x: Int, erased y: Int) => Int
    type Function2 = (Int, erased Int) => Int

Use refined traits for erased functions

- function types with erased parameters are now always `ErasedFunction` refined with the correct `apply` definition,
  for example:

    scala.ErasedFunction {
        def apply(x1: Int, erased x2: Int): Int
    }
  where ErasedFunctions is an @experimental empty trait.

Author: natsukagami

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

@@ -1496,10 +1496,10 @@ object desugar {
       case vd: ValDef => vd
     }
 
-  def makeContextualFunction(formals: List[Tree], body: Tree, isErased: Boolean)(using Context): Function = {
-    val mods = if (isErased) Given | Erased else Given
+  def makeContextualFunction(formals: List[Tree], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
+    val mods = Given
     val params = makeImplicitParameters(formals, mods)
-    FunctionWithMods(params, body, Modifiers(mods))
+    FunctionWithMods(params, body, Modifiers(mods), erasedParams)
   }
 
   private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(using Context) = {
@@ -1832,6 +1832,7 @@ object desugar {
             cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))
           case _ =>
             annotate(tpnme.retains, parent)
+      case f: FunctionWithMods if f.erasedParams.contains(true) => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
   }
@@ -1907,6 +1908,28 @@ object desugar {
     TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait)
   }
 
+  /** Ensure the given function tree use only ValDefs for parameters.
+   *  For example,
+   *      FunctionWithMods(List(TypeTree(A), TypeTree(B)), body, mods, erasedParams)
+   *  gets converted to
+   *      FunctionWithMods(List(ValDef(x$1, A), ValDef(x$2, B)), body, mods, erasedParams)
+   */
+  def makeFunctionWithValDefs(tree: Function, pt: Type)(using Context): Function = {
+    val Function(args, result) = tree
+    args match {
+      case (_ : ValDef) :: _ => tree // ValDef case can be easily handled
+      case _ if !ctx.mode.is(Mode.Type) => tree
+      case _ =>
+        val applyVParams = args.zipWithIndex.map {
+          case (p, n) => makeSyntheticParameter(n + 1, p)
+        }
+        tree match
+          case tree: FunctionWithMods =>
+            untpd.FunctionWithMods(applyVParams, tree.body, tree.mods, tree.erasedParams)
+          case _ => untpd.Function(applyVParams, result)
+    }
+  }
+
   /** Returns list of all pattern variables, possibly with their types,
    *  without duplicates
    */

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

@@ -952,7 +952,9 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       && tree.isTerm
       && {
         val qualType = tree.qualifier.tpe
-        hasRefinement(qualType) && !qualType.derivesFrom(defn.PolyFunctionClass)
+        hasRefinement(qualType) &&
+          !qualType.derivesFrom(defn.PolyFunctionClass) &&
+          !defn.isErasedFunctionType(qualType)
       }
     def loop(tree: Tree): Boolean = tree match
       case TypeApply(fun, _) =>

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
+          val maybeErased = if isErased then Erased else EmptyFlags
 
           def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
 
@@ -277,7 +277,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
               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(tp.erasedParams).map(valueParam), Nil)
         val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
         (rtp, vparams :: paramss)
       case _ =>
@@ -1130,10 +1130,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionType(argTypes, resType, isErased) =>
+        case defn.ContextFunctionType(argTypes, resType, erasedParams) =>
           val anonFun = newAnonFun(
             ctx.owner,
-            MethodType.companion(isContextual = true, isErased = isErased)(argTypes, resType),
+            MethodType.companion(isContextual = true, erasedParams = erasedParams)(argTypes, resType),
             coord = ctx.owner.coord)
           def lambdaBody(refss: List[List[Tree]]) =
             expand(target.select(nme.apply).appliedToArgss(refss), resType)(

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

@@ -77,8 +77,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
 
   /** A function type or closure with `implicit`, `erased`, or `given` modifiers */
-  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers)(implicit @constructorOnly src: SourceFile)
-    extends Function(args, body)
+  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers, val erasedParams: List[Boolean])(implicit @constructorOnly src: SourceFile)
+    extends Function(args, body) {
+      assert(args.length == erasedParams.length)
+    }
 
   /** A polymorphic function type */
   case class PolyFunction(targs: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends Tree {

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

@@ -146,7 +146,6 @@ extension (tp: Type)
       defn.FunctionType(
         fname.functionArity,
         isContextual = fname.isContextFunction,
-        isErased = fname.isErasedFunction,
         isImpure = true).appliedTo(args)
     case _ =>
       tp

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

@@ -336,8 +336,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         mapArgUsing(_.forceBoxStatus(false))
       else if meth == defn.Caps_unsafeBoxFunArg then
         mapArgUsing {
-          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, isErased) =>
-            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, isErased)
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, erasedParams) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, erasedParams)
         }
       else
         super.recheckApply(tree, pt) match
@@ -598,18 +598,18 @@ 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 =
-      MethodType.companion(isContextual = isContextual, isErased = isErased)(args, resultType)
+    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, erasedParams: List[Boolean])(using Context): Type =
+      MethodType.companion(isContextual = isContextual, erasedParams = erasedParams)(args, resultType)
         .toFunctionType(isJava = false, alwaysDependent = true)
 
     /** Turn `expected` into a dependent function when `actual` is dependent. */
     private def alignDependentFunction(expected: Type, actual: Type)(using Context): Type =
       def recur(expected: Type): Type = expected.dealias match
         case expected @ CapturingType(eparent, refs) =>
           CapturingType(recur(eparent), refs, boxed = expected.isBoxed)
-        case expected @ defn.FunctionOf(args, resultType, isContextual, isErased)
+        case expected @ defn.FunctionOf(args, resultType, isContextual, erasedParams)
           if defn.isNonRefinedFunction(expected) && defn.isFunctionType(actual) && !defn.isNonRefinedFunction(actual) =>
-          val expected1 = toDepFun(args, resultType, isContextual, isErased)
+          val expected1 = toDepFun(args, resultType, isContextual, erasedParams)
           expected1
         case _ =>
           expected

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

@@ -38,7 +38,7 @@ extends tpd.TreeTraverser:
   private def depFun(tycon: Type, argTypes: List[Type], resType: Type)(using Context): Type =
     MethodType.companion(
         isContextual = defn.isContextFunctionClass(tycon.classSymbol),
-        isErased = defn.isErasedFunctionClass(tycon.classSymbol)
+        erasedParams = defn.erasedFunctionParameters(tycon)
       )(argTypes, resType)
       .toFunctionType(isJava = false, alwaysDependent = true)
 
@@ -260,7 +260,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, erasedParams = List(true))
     case _ => tp
 
   private def expandThrowsAliases(using Context) = new TypeMap:

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

@@ -86,7 +86,7 @@ class Definitions {
     newPermanentClassSymbol(ScalaPackageClass, name, Artifact, completer).entered
   }
 
-  /** The trait FunctionN, ContextFunctionN, ErasedFunctionN or ErasedContextFunction, for some N
+  /** The trait FunctionN and ContextFunctionN for some N
    *  @param  name   The name of the trait to be created
    *
    *  FunctionN traits follow this template:
@@ -104,21 +104,6 @@ class Definitions {
    *      trait ContextFunctionN[-T0,...,-T{N-1}, +R] extends Object {
    *        def apply(using $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
-   *
-   *  ErasedFunctionN traits follow this template:
-   *
-   *      trait ErasedFunctionN[-T0,...,-T{N-1}, +R] extends Object {
-   *        def apply(erased $x0: T0, ..., $x{N_1}: T{N-1}): R
-   *      }
-   *
-   *  ErasedContextFunctionN traits follow this template:
-   *
-   *      trait ErasedContextFunctionN[-T0,...,-T{N-1}, +R] extends Object {
-   *        def apply(using erased $x0: T0, ..., $x{N_1}: T{N-1}): R
-   *      }
-   *
-   *  ErasedFunctionN and ErasedContextFunctionN erase to Function0.
-   *
    *  ImpureXYZFunctionN follow this template:
    *
    *      type ImpureXYZFunctionN[-T0,...,-T{N-1}, +R] = {*} XYZFunctionN[T0,...,T{N-1}, R]
@@ -150,7 +135,7 @@ class Definitions {
           val methodType = MethodType.companion(
             isContextual = name.isContextFunction,
             isImplicit = false,
-            isErased = name.isErasedFunction)
+            erasedParams = List())
           decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
           denot.info =
             ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
@@ -1095,15 +1080,24 @@ 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)] = {
-      val tsym = ft.typeSymbol
-      if isFunctionClass(tsym) && ft.isRef(tsym) then
-        val targs = ft.dealias.argInfos
-        if (targs.isEmpty) None
-        else Some(targs.init, targs.last, tsym.name.isContextFunction, tsym.name.isErasedFunction)
-      else None
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, erasedParams: List[Boolean] = List())(using Context): Type =
+      assert(erasedParams.size == 0 || args.size == erasedParams.size)
+      if erasedParams.contains(true) then
+        val mt = MethodType.companion(isContextual, false, erasedParams.padTo(args.size, false))(args, resultType)
+        RefinedType(ErasedFunctionClass.typeRef, nme.apply, mt)
+      else
+        FunctionType(args.length, isContextual).appliedTo(args ::: resultType :: Nil)
+    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, List[Boolean])] = {
+      ft.dealias match
+        case RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) =>
+          Some(mt.paramInfos, mt.resType, mt.isContextualMethod, mt.erasedParams)
+        case _ =>
+          val tsym = ft.dealias.typeSymbol
+          if isFunctionSymbol(tsym) && ft.isRef(tsym) then
+            val targs = ft.dealias.argInfos
+            if (targs.isEmpty) None
+            else Some(targs.init, targs.last, tsym.name.isContextFunction, List.fill(targs.init.size) { false })
+          else None
     }
   }
 
@@ -1422,24 +1416,22 @@ class Definitions {
       classRefs(n).nn
   end FunType
 
-  private def funTypeIdx(isContextual: Boolean, isErased: Boolean, isImpure: Boolean): Int =
+  private def funTypeIdx(isContextual: Boolean, isImpure: Boolean): Int =
       (if isContextual then 1 else 0)
-    + (if isErased     then 2 else 0)
-    + (if isImpure     then 4 else 0)
+    + (if isImpure     then 2 else 0)
 
   private val funTypeArray: IArray[FunType] =
     val arr = Array.ofDim[FunType](8)
     val choices = List(false, true)
-    for contxt <- choices; erasd <- choices; impure <- choices do
+    for contxt <- choices; impure <- choices do
       var str = "Function"
       if contxt then str = "Context" + str
-      if erasd then str = "Erased" + str
       if impure then str = "Impure" + str
-      arr(funTypeIdx(contxt, erasd, impure)) = FunType(str)
+      arr(funTypeIdx(contxt, impure)) = FunType(str)
     IArray.unsafeFromArray(arr)
 
-  def FunctionSymbol(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isImpure: Boolean = false)(using Context): Symbol =
-    funTypeArray(funTypeIdx(isContextual, isErased, isImpure))(n).symbol
+  def FunctionSymbol(n: Int, isContextual: Boolean = false, isImpure: Boolean = false)(using Context): Symbol =
+    funTypeArray(funTypeIdx(isContextual, isImpure))(n).symbol
 
   @tu lazy val Function0_apply: Symbol = Function0.requiredMethod(nme.apply)
   @tu lazy val ContextFunction0_apply: Symbol = ContextFunction0.requiredMethod(nme.apply)
@@ -1449,12 +1441,14 @@ class Definitions {
   @tu lazy val Function2: Symbol = FunctionSymbol(2)
   @tu lazy val ContextFunction0: Symbol = FunctionSymbol(0, isContextual = true)
 
-  def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isImpure: Boolean = false)(using Context): TypeRef =
-    FunctionSymbol(n, isContextual && !ctx.erasedTypes, isErased, isImpure).typeRef
+  def FunctionType(n: Int, isContextual: Boolean = false, isImpure: Boolean = false)(using Context): TypeRef =
+    FunctionSymbol(n, isContextual && !ctx.erasedTypes, isImpure).typeRef
 
   lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
   def PolyFunctionType = PolyFunctionClass.typeRef
 
+  lazy val ErasedFunctionClass = requiredClass("scala.runtime.ErasedFunction")
+
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(using Context): TypeName = cls.denot match
     case clsd: ClassDenotation if clsd.owner eq ScalaPackageClass =>
@@ -1485,10 +1479,9 @@ class Definitions {
 
   /** Is any function class where
    *   - FunctionXXL
+   *   - ErasedFunction
    *   - FunctionN for N >= 0
    *   - ContextFunctionN for N >= 0
-   *   - ErasedFunctionN for N > 0
-   *   - ErasedContextFunctionN for N > 0
    */
   def isFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isFunction
 
@@ -1507,12 +1500,6 @@ class Definitions {
    */
   def isContextFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isContextFunction
 
-  /** Is an erased function class.
-   *   - ErasedFunctionN for N > 0
-   *   - ErasedContextFunctionN for N > 0
-   */
-  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction
-
   /** Is either FunctionXXL or  a class that will be erased to FunctionXXL
    *   - FunctionXXL
    *   - FunctionN for N >= 22
@@ -1549,8 +1536,7 @@ class Definitions {
    */
   def functionTypeErasure(cls: Symbol): Type =
     val arity = scalaClassName(cls).functionArity
-    if cls.name.isErasedFunction then FunctionType(0)
-    else if arity > 22 then FunctionXXLClass.typeRef
+    if arity > 22 then FunctionXXLClass.typeRef
     else if arity >= 0 then FunctionType(arity)
     else NoType
 
@@ -1681,13 +1667,13 @@ class Definitions {
     arity >= 0
     && isFunctionClass(sym)
     && tp.isRef(
-        FunctionType(arity, sym.name.isContextFunction, sym.name.isErasedFunction).typeSymbol,
+        FunctionType(arity, sym.name.isContextFunction).typeSymbol,
         skipRefined = false)
   end isNonRefinedFunction
 
   /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
   def isFunctionType(tp: Type)(using Context): Boolean =
-    isNonRefinedFunction(tp.dropDependentRefinement)
+    isNonRefinedFunction(tp.dropDependentRefinement) || isErasedFunctionType(tp)
 
   def isFunctionOrPolyType(tp: Type)(using Context): Boolean =
     isFunctionType(tp) || (tp.typeSymbol eq defn.PolyFunctionClass)
@@ -1779,7 +1765,7 @@ class Definitions {
   @tu lazy val FunctionSpecializedApplyNames: collection.Set[Name] =
     Function0SpecializedApplyNames ++ Function1SpecializedApplyNames ++ Function2SpecializedApplyNames
 
-  def functionArity(tp: Type)(using Context): Int = tp.dropDependentRefinement.dealias.argInfos.length - 1
+  def functionArity(tp: Type)(using Context): Int = tp.functionArgInfos.length - 1
 
   /** Return underlying context function type (i.e. instance of an ContextFunctionN class)
    *  or NoType if none exists. The following types are considered as underlying types:
@@ -1791,6 +1777,8 @@ class Definitions {
     tp.stripTypeVar.dealias match
       case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
         asContextFunctionType(TypeComparer.bounds(tp1).hiBound)
+      case tp1 @ RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) && mt.isContextualMethod =>
+        tp1
       case tp1 =>
         if tp1.typeSymbol.name.isContextFunction && isFunctionType(tp1) then tp1
         else NoType
@@ -1804,18 +1792,28 @@ class Definitions {
    *  types `As`, the result type `B` and a whether the type is an erased context function.
    */
   object ContextFunctionType:
-    def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
+    def unapply(tp: Type)(using Context): Option[(List[Type], Type, List[Boolean])] =
       if ctx.erasedTypes then
         atPhase(erasurePhase)(unapply(tp))
       else
-        val tp1 = asContextFunctionType(tp)
-        if tp1.exists then
-          val args = tp1.dropDependentRefinement.argInfos
-          Some((args.init, args.last, tp1.typeSymbol.name.isErasedFunction))
-        else None
+        asContextFunctionType(tp) match
+          case RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) =>
+            Some((mt.paramInfos, mt.resType, mt.erasedParams))
+          case tp1 if tp1.exists =>
+            val args = tp1.functionArgInfos
+            val erasedParams = erasedFunctionParameters(tp1)
+            Some((args.init, args.last, erasedParams))
+          case _ => 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: MethodType) => mt.erasedParams
+    case tp if isFunctionType(tp) => List.fill(functionArity(tp)) { false }
+    case _ => Nil
+  }
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+    tp.derivesFrom(defn.ErasedFunctionClass)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =