Generate "Impure" function aliases

For every (possibly erased and/or context) function class XFunctionN, generate an alias ImpureXFunctionN in the Scala package defined as type ImpureXFunctionN[...] = {*} XFunctionN[...]

Author: odersky

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

@@ -8,7 +8,7 @@ import Flags._, Scopes._, Decorators._, NameOps._, Periods._, NullOpsDecorator._
 import unpickleScala2.Scala2Unpickler.ensureConstructor
 import scala.collection.mutable
 import collection.mutable
-import Denotations.SingleDenotation
+import Denotations.{SingleDenotation, staticRef}
 import util.{SimpleIdentityMap, SourceFile, NoSource}
 import typer.ImportInfo.RootRef
 import Comments.CommentsContext
@@ -86,7 +86,7 @@ class Definitions {
  *
  * FunctionN traits follow this template:
  *
- * trait FunctionN[T0,...T{N-1}, R] extends Object {
+ * trait FunctionN[-T0,...-T{N-1}, +R] extends Object {
  * def apply($x0: T0, ..., $x{N_1}: T{N-1}): R
  * }
  *
@@ -96,46 +96,65 @@ class Definitions {
  *
  * ContextFunctionN traits follow this template:
  *
- * trait ContextFunctionN[T0,...,T{N-1}, R] extends Object {
+ * 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 {
+ * 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 {
+ * 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.
+ *
+ * EffXYZFunctionN afollow this template:
+ *
+ * type EffXYZFunctionN[-T0,...,-T{N-1}, +R] = {*} XYZFunctionN[T0,...,T{N-1}, R]
  */
- def newFunctionNTrait(name: TypeName): ClassSymbol = {
+ private def newFunctionNType(name: TypeName): Symbol = {
+ val impure = name.startsWith("Impure")
  val completer = new LazyType {
  def complete(denot: SymDenotation)(using Context): Unit = {
- val cls = denot.asClass.classSymbol
- val decls = newScope
  val arity = name.functionArity
- val paramNamePrefix = tpnme.scala ++ str.NAME_JOIN ++ name ++ str.EXPAND_SEPARATOR
- val argParamRefs = List.tabulate(arity) { i =>
- enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
- }
- val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
- val methodType = MethodType.companion(
- isContextual = name.isContextFunction,
- isImplicit = false,
- isErased = name.isErasedFunction)
- decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
- denot.info =
- ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
+ if impure then
+ val argParamNames = List.tabulate(arity)(tpnme.syntheticTypeParamName)
+ val argVariances = List.fill(arity)(Contravariant)
+ val underlyingName = name.asSimpleName.drop(6)
+ val underlyingClass = ScalaPackageVal.requiredClass(underlyingName)
+ denot.info = TypeAlias(
+ HKTypeLambda(argParamNames :+ "R".toTypeName, argVariances :+ Covariant)(
+ tl => List.fill(arity + 1)(TypeBounds.empty),
+ tl => CapturingType(underlyingClass.typeRef.appliedTo(tl.paramRefs),
+ CaptureSet.universal, boxed = false)
+ ))
+ else
+ val cls = denot.asClass.classSymbol
+ val decls = newScope
+ val paramNamePrefix = tpnme.scala ++ str.NAME_JOIN ++ name ++ str.EXPAND_SEPARATOR
+ val argParamRefs = List.tabulate(arity) { i =>
+ enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
+ }
+ val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
+ val methodType = MethodType.companion(
+ isContextual = name.isContextFunction,
+ isImplicit = false,
+ isErased = name.isErasedFunction)
+ decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
+ denot.info =
+ ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
  }
  }
- val flags = Trait | NoInits
- newPermanentClassSymbol(ScalaPackageClass, name, flags, completer)
+ if impure then
+ newPermanentSymbol(ScalaPackageClass, name, EmptyFlags, completer)
+ else
+ newPermanentClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
  }
 
  private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
@@ -209,7 +228,7 @@ class Definitions {
  val cls = ScalaPackageVal.moduleClass.asClass
  cls.info.decls.openForMutations.useSynthesizer(
  name =>
- if (name.isTypeName && name.isSyntheticFunction) newFunctionNTrait(name.asTypeName)
+ if (name.isTypeName && name.isSyntheticFunction) newFunctionNType(name.asTypeName)
  else NoSymbol)
  cls
  }
@@ -1273,37 +1292,55 @@ class Definitions {
 
  @tu lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
+ /** Cached function types of arbitary arities.
+ * Function types are created on demand with newFunctionNTrait, which is
+ * called from a synthesizer installed in ScalaPackageClass.
+ */
  private class FunType(prefix: String):
  private var classRefs: Array[TypeRef] = new Array(22)
+
  def apply(n: Int): TypeRef =
  while n >= classRefs.length do
  val classRefs1 = new Array[TypeRef](classRefs.length * 2)
  Array.copy(classRefs, 0, classRefs1, 0, classRefs.length)
  classRefs = classRefs1
+ val funName = prefix + n.toString
  if classRefs(n) == null then
- classRefs(n) = requiredClassRef(prefix + n.toString)
+ classRefs(n) =
+ if prefix.startsWith("Impure")
+ then staticRef(funName.toTypeName).symbol.typeRef
+ else requiredClassRef(funName)
  classRefs(n)
+ end FunType
+
+ private val (funTypeCache, funTypeArray) =
+ val funTypeCache = mutable.Map[String, FunType]()
+ val funTypeArray = Array.ofDim[FunType](2, 2, 2)
+
+ for contxt <- 0 to 1; erasd <- 0 to 1; impure <- 0 to 1 do
+ var str = "Function"
+ if contxt == 1 then str = "Context" + str
+ if erasd == 1 then str = "Erased" + str
+ if impure == 1 then str = "Impure" + str
+ val funType = FunType("scala." + str)
+ funTypeCache(str) = funType
+ funTypeArray(contxt)(erasd)(impure) = funType
 
- private val erasedContextFunType = FunType("scala.ErasedContextFunction")
- private val contextFunType = FunType("scala.ContextFunction")
- private val erasedFunType = FunType("scala.ErasedFunction")
- private val funType = FunType("scala.Function")
+ (funTypeCache: collection.Map[String, FunType], IArray.unsafeFromArray(funTypeArray))
+ end val
 
- def FunctionClass(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(using Context): Symbol =
- ( if isContextual && isErased then erasedContextFunType(n)
- else if isContextual then contextFunType(n)
- else if isErased then erasedFunType(n)
- else funType(n)
- ).symbol.asClass
+ def FunctionSymbol(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isEffectful: Boolean = false)(using Context): Symbol =
+ def ord(b: Boolean): Int = if b then 1 else 0
+ funTypeArray(ord(isContextual))(ord(isErased))(ord(isEffectful))(n).symbol
 
  @tu lazy val Function0_apply: Symbol = Function0.requiredMethod(nme.apply)
 
- @tu lazy val Function0: Symbol = FunctionClass(0)
- @tu lazy val Function1: Symbol = FunctionClass(1)
- @tu lazy val Function2: Symbol = FunctionClass(2)
+ @tu lazy val Function0: Symbol = FunctionSymbol(0)
+ @tu lazy val Function1: Symbol = FunctionSymbol(1)
+ @tu lazy val Function2: Symbol = FunctionSymbol(2)
 
- def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(using Context): TypeRef =
- FunctionClass(n, isContextual && !ctx.erasedTypes, isErased).typeRef
+ def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isEffectful: Boolean = false)(using Context): TypeRef =
+ FunctionSymbol(n, isContextual && !ctx.erasedTypes, isErased, isEffectful).typeRef
 
  lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
  def PolyFunctionType = PolyFunctionClass.typeRef
@@ -1550,7 +1587,7 @@ class Definitions {
  new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
 
  def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
- paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length))
+ paramTypes.length <= 2 && cls.derivesFrom(FunctionSymbol(paramTypes.length))
  && isSpecializableFunctionSAM(paramTypes, retType)
 
  /** If the Single Abstract Method of a Function class has this type, is it specializable? */

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

@@ -197,20 +197,25 @@ object NameOps {
  else collectDigits(acc * 10 + d, idx + 1)
  collectDigits(0, suffixStart + 8)
 
- /** name[0..suffixStart) == `str` */
- private def isPreceded(str: String, suffixStart: Int) =
- str.length == suffixStart && name.firstPart.startsWith(str)
+ private def isFunctionPrefix(suffixStart: Int, mustHave: String = ""): Boolean =
+ suffixStart >= 0
+ && {
+ val first = name.firstPart
+ var found = mustHave.isEmpty
+ def skip(idx: Int, str: String) =
+ if first.startsWith(str, idx) then
+ if str == mustHave then found = true
+ idx + str.length
+ else idx
+ skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
+ && found
+ }
 
  /** Same as `funArity`, except that it returns -1 if the prefix
  * is not one of "", "Context", "Erased", "ErasedContext"
  */
  private def checkedFunArity(suffixStart: Int): Int =
- if suffixStart == 0
- || isPreceded("Context", suffixStart)
- || isPreceded("Erased", suffixStart)
- || isPreceded("ErasedContext", suffixStart)
- then funArity(suffixStart)
- else -1
+ if isFunctionPrefix(suffixStart) then funArity(suffixStart) else -1
 
  /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ErasedFunctionN, ErasedContextFunctionN for N >= 0
  */
@@ -226,15 +231,13 @@ object NameOps {
  */
  def isContextFunction: Boolean =
  val suffixStart = functionSuffixStart
- (isPreceded("Context", suffixStart) || isPreceded("ErasedContext", suffixStart))
- && funArity(suffixStart) >= 0
+ isFunctionPrefix(suffixStart, mustHave = "Context") && funArity(suffixStart) >= 0
 
  /** Is an erased function name, i.e. one of ErasedFunctionN, ErasedContextFunctionN for N >= 0
  */
  def isErasedFunction: Boolean =
  val suffixStart = functionSuffixStart
- (isPreceded("Erased", suffixStart) || isPreceded("ErasedContext", suffixStart))
- && funArity(suffixStart) >= 0
+ isFunctionPrefix(suffixStart, mustHave = "Erased") && funArity(suffixStart) >= 0
 
  /** Is a synthetic function name, i.e. one of
  * - FunctionN for N > 22

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

@@ -815,7 +815,7 @@ trait Implicits:
  def isOldStyleFunctionConversion(tpe: Type): Boolean =
  tpe match {
  case PolyType(_, resType) => isOldStyleFunctionConversion(resType)
- case _ => tpe.derivesFrom(defn.FunctionClass(1)) && !tpe.derivesFrom(defn.ConversionClass) && !tpe.derivesFrom(defn.SubTypeClass)
+ case _ => tpe.derivesFrom(defn.FunctionSymbol(1)) && !tpe.derivesFrom(defn.ConversionClass) && !tpe.derivesFrom(defn.SubTypeClass)
  }
 
  try

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

@@ -1238,7 +1238,7 @@ class Typer extends Namer
  val numArgs = args.length
  val isContextual = funFlags.is(Given)
  val isErased = funFlags.is(Erased)
- val funCls = defn.FunctionClass(numArgs, isContextual, isErased)
+ val funCls = defn.FunctionSymbol(numArgs, isContextual, isErased)
 
  /** If `app` is a function type with arguments that are all erased classes,
  * turn it into an erased function type.
@@ -1248,7 +1248,7 @@ class Typer extends Namer
  if !isErased
  && numArgs > 0
  && args.indexWhere(!_.tpe.isErasedClass) == numArgs =>
- val tycon1 = TypeTree(defn.FunctionClass(numArgs, isContextual, isErased = true).typeRef)
+ val tycon1 = TypeTree(defn.FunctionSymbol(numArgs, isContextual, isErased = true).typeRef)
  .withSpan(tycon.span)
  assignType(cpy.AppliedTypeTree(app)(tycon1, args), tycon1, args)
  case _ =>

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2692,7 +2692,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
  def SomeModule: Symbol = dotc.core.Symbols.defn.SomeClass.companionModule
  def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass
  def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
- dotc.core.Symbols.defn.FunctionClass(arity, isImplicit, isErased)
+ dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit, isErased)
  def TupleClass(arity: Int): Symbol =
  dotc.core.Symbols.defn.TupleType(arity).classSymbol.asClass
  def isTupleClass(sym: Symbol): Boolean =

tests/pos/impurefun.scala

@@ -0,0 +1,4 @@
+object Test:
+
+ val f: ImpureFunction1[Int, Int] = (x: Int) => x + 1
+