Add support for functions with phantom parameters

Author: nicolasstucki

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

@@ -60,14 +60,14 @@ class Definitions {
   private def enterCompleteClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, parents: List[TypeRef], decls: Scope = newScope) =
     ctx.newCompleteClassSymbol(owner, name, flags | Permanent, parents, decls).entered
 
-  private def enterTypeField(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
-    scope.enter(newSymbol(cls, name, flags, TypeBounds.empty))
+  private def enterTypeField(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope, typeBounds: TypeBounds) =
+    scope.enter(newSymbol(cls, name, flags, typeBounds))
 
-  private def enterTypeParam(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
-    enterTypeField(cls, name, flags | ClassTypeParamCreationFlags, scope)
+  private def enterTypeParam(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope, typeBounds: TypeBounds) =
+    enterTypeField(cls, name, flags | ClassTypeParamCreationFlags, scope, typeBounds)
 
   private def enterSyntheticTypeParam(cls: ClassSymbol, paramFlags: FlagSet, scope: MutableScope, suffix: String = "T0") =
-    enterTypeParam(cls, suffix.toTypeName.expandedName(cls), ExpandedName | paramFlags, scope)
+    enterTypeParam(cls, suffix.toTypeName.expandedName(cls), ExpandedName | paramFlags, scope, TypeBounds.empty)
 
   // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
   // implemented in Dotty and not in Scala 2.
@@ -89,7 +89,7 @@ class Definitions {
     newClassSymbol(ScalaPackageClass, name, EmptyFlags, completer).entered
   }
 
-  /** The trait FunctionN or ImplicitFunctionN, for some N
+  /** The trait FunctionN, ImplicitFunctionN, PhantomFunctionM, ImplicitPhantomFunctionM, for some N
    *  @param  name   The name of the trait to be created
    *
    *  FunctionN traits follow this template:
@@ -107,30 +107,45 @@ class Definitions {
    *      trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object with FunctionN[T0,...,T{N-1}, R] {
    *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
+   *
+   *  PhantomFunctionM traits follow this template:
+   *
+   *      trait PhantomFunctionM[T0,...T{N-1}, R] extends Object {
+   *        def apply($x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *      where M represents the phantomicity of all Ti.
+   *
+   *  ImplicitPhantomFunctionM traits follow this template:
+   *
+   *      trait ImplicitPhantomFunctionM[T0,...,T{N-1}, R] extends Object with PhantomFunctionM[T0,...,T{N-1}, R] {
+   *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *      where M represents the phantomicity of all Ti.
+   *
    */
   private def newFunctionNTrait(name: TypeName) = {
     val completer = new LazyType {
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        val arity = name.functionArity
+        val phantomicity = name.phantomicity
+        val arity = phantomicity.arity
         val argParams =
           for (i <- List.range(0, arity)) yield
-            enterTypeParam(cls, name ++ "$T" ++ i.toString, Contravariant, decls)
-        val resParam = enterTypeParam(cls, name ++ "$R", Covariant, decls)
+            enterTypeParam(cls, name ++ "$T" ++ i.toString, Contravariant, decls, phantomicity.tParamBounds(i)).typeRef
+        val resParam = enterTypeParam(cls, name ++ "$R", Covariant, decls, phantomicity.tParamBounds(arity)).typeRef
         val (methodType, parentTraits) =
-          if (name.startsWith(tpnme.ImplicitFunction)) {
-            val superTrait =
-              FunctionType(arity).appliedTo(argParams.map(_.typeRef) ::: resParam.typeRef :: Nil)
-            (ImplicitMethodType, ctx.normalizeToClassRefs(superTrait :: Nil, cls, decls))
+          if (name.isImplicitFunction) {
+            val superTrait = FunctionType(phantomicity, isImplicit = false)
+            val appliedSuperTrait = superTrait.appliedTo(argParams ::: resParam :: Nil)
+            (ImplicitMethodType, ctx.normalizeToClassRefs(appliedSuperTrait :: Nil, cls, decls))
           }
           else (MethodType, Nil)
-        val applyMeth =
-          decls.enter(
-            newMethod(cls, nme.apply,
-              methodType(argParams.map(_.typeRef), resParam.typeRef), Deferred))
-        denot.info =
-          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
+
+        decls.enter(newMethod(cls, nme.apply, methodType(argParams, resParam), Deferred))
+        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
       }
     }
     newClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
@@ -640,7 +655,7 @@ class Definitions {
 
   object FunctionOf {
     def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false)(implicit ctx: Context) =
-      FunctionType(args.length, isImplicit).appliedTo(args ::: resultType :: Nil)
+      FunctionType(Phantomicity(args :+ resultType), isImplicit).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context) = {
       val tsym = ft.typeSymbol
       if (isFunctionClass(tsym)) {
@@ -698,18 +713,30 @@ class Definitions {
   lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
   lazy val ProductNType = mkArityArray("scala.Product", MaxTupleArity, 0)
 
-  def FunctionClass(n: Int, isImplicit: Boolean = false)(implicit ctx: Context) =
+  def FunctionClass(n: Int, isImplicit: Boolean = false)(implicit ctx: Context): Symbol =
     if (isImplicit) ctx.requiredClass("scala.ImplicitFunction" + n.toString)
     else if (n <= MaxImplementedFunctionArity) FunctionClassPerRun()(ctx)(n)
     else ctx.requiredClass("scala.Function" + n.toString)
 
+  def FunctionClass(phantomicity: Phantomicity, isImplicit: Boolean)(implicit ctx: Context): Symbol = {
+    if (phantomicity.hasPhantoms) {
+      val prefix = if (isImplicit) "scala.ImplicitPhantomFunction" else "scala.PhantomFunction"
+      ctx.requiredClass(prefix + phantomicity.encodedString)
+    } else FunctionClass(phantomicity.arity, isImplicit)
+  }
+
     lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
     def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
 
   def FunctionType(n: Int, isImplicit: Boolean = false)(implicit ctx: Context): TypeRef =
     if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes)) ImplementedFunctionType(n)
     else FunctionClass(n, isImplicit).typeRef
 
+  def FunctionType(phantomicity: Phantomicity, isImplicit: Boolean)(implicit ctx: Context): TypeRef = {
+    if (phantomicity.hasPhantoms) FunctionClass(phantomicity, isImplicit).typeRef
+    else FunctionType(phantomicity.arity, isImplicit)
+  }
+
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
   private lazy val ProductTypes: Set[TypeRef] = ProductNType.toSet
 
@@ -735,23 +762,37 @@ class Definitions {
   /** Is a function class.
    *   - FunctionN for N >= 0
    *   - ImplicitFunctionN for N >= 0
+   *   - PhantomFunctionM for a valid M
+   *   - ImplicitPhantomFunctionM for a valid M
    */
   def isFunctionClass(cls: Symbol) = scalaClassName(cls).isFunction
 
   /** Is an implicit function class.
    *   - ImplicitFunctionN for N >= 0
+   *   - ImplicitPhantomFunctionN for a valid M
    */
   def isImplicitFunctionClass(cls: Symbol) = scalaClassName(cls).isImplicitFunction
 
+  /** Is a phantom function class.
+    *   - PhantomFunctionM for a valid M
+    *   - ImplicitPhantomFunctionM for a valid M
+    */
+  def isPhantomFunctionClass(cls: Symbol) = scalaClassName(cls).isPhantomFunction
+
   /** Is a class that will be erased to FunctionXXL
    *   - FunctionN for N >= 22
    *   - ImplicitFunctionN for N >= 22
+   *   - PhantomFunctionM for N >= 22, where N is the number of non phantoms in M
+   *   - ImplicitPhantomFunctionM for N >= 22, where N is the number of non phantoms in M
    */
-  def isXXLFunctionClass(cls: Symbol) = scalaClassName(cls).functionArity > MaxImplementedFunctionArity
+  def isXXLFunctionClass(cls: Symbol) =
+    scalaClassName(cls).phantomicity.erasedArity > MaxImplementedFunctionArity
 
   /** Is a synthetic function class
    *    - FunctionN for N > 22
    *    - ImplicitFunctionN for N >= 0
+   *    - PhantomFunctionM for a valid M
+   *    - ImplicitPhantomFunctionM for a valid M
    */
   def isSyntheticFunctionClass(cls: Symbol) = scalaClassName(cls).isSyntheticFunction
 
@@ -760,31 +801,42 @@ class Definitions {
   def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product)
 
   /** Returns the erased class of the function class `cls`
-   *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
-   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
+   *    - FunctionN for N > 22 becomes FunctionXXL
    *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
    *    - anything else becomes a NoSymbol
    */
   def erasedFunctionClass(cls: Symbol): Symbol = {
-    val arity = scalaClassName(cls).functionArity
-    if (arity > 22) defn.FunctionXXLClass
-    else if (arity >= 0) defn.FunctionClass(arity)
-    else NoSymbol
+    val phantomicity = scalaClassName(cls).phantomicity
+    if (!phantomicity.isValid) NoSymbol
+    else if (phantomicity.erasedArity > 22) defn.FunctionXXLClass
+    else defn.FunctionClass(phantomicity.erasedArity)
+  }
+
+  /** Returns the erased class of the function class `cls`
+   *    - PhantomFunctionM becomes FunctionN where N is the number of non phantoms in M
+   *    - ImplicitPhantomFunctionM becomes ImplicitFunctionN where N is the number of non phantoms in M
+   *    - cls otherwise
+   */
+  def erasedPhantomsFunctionClass(cls: Symbol): Symbol = {
+    val phantomicity = scalaClassName(cls).phantomicity
+    if (!phantomicity.isValid) cls
+    else defn.FunctionClass(phantomicity.erasedArity, cls.name.isImplicitFunction)
   }
 
   /** Returns the erased type of the function class `cls`
-   *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
-   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
+   *    - FunctionN for N > 22 becomes FunctionXXL
    *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
    *    - anything else becomes a NoType
    */
   def erasedFunctionType(cls: Symbol): Type = {
-    val arity = scalaClassName(cls).functionArity
-    if (arity > 22) defn.FunctionXXLType
-    else if (arity >= 0) defn.FunctionType(arity)
-    else NoType
+    val phantomicity = scalaClassName(cls).phantomicity
+    if (!phantomicity.isValid) NoType
+    else if (phantomicity.erasedArity > 22) defn.FunctionXXLType
+    else defn.FunctionType(phantomicity.erasedArity)
   }
 
   val predefClassNames: Set[Name] =
@@ -828,7 +880,10 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  lazy val NoInitClasses = NotRuntimeClasses + FunctionXXLClass
+  private lazy val NoInitClasses = NotRuntimeClasses + FunctionXXLClass
+
+  def isNoInitClass(cls: Symbol): Boolean =
+    cls.is(NoInitsTrait) || NoInitClasses.contains(cls) || isFunctionClass(cls)
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
@@ -857,7 +912,7 @@ class Definitions {
   def isFunctionType(tp: Type)(implicit ctx: Context) = {
     val arity = functionArity(tp)
     val sym = tp.dealias.typeSymbol
-    arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction).typeSymbol)
+    arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(sym.name.phantomicity, sym.name.isImplicitFunction).typeSymbol)
   }
 
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
@@ -1013,14 +1068,16 @@ class Definitions {
   def isPhantomAssume(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.exists && (sym.owner eq PhantomClass) && sym.name == nme.assume_
 
-  def topOf(tp: Type)(implicit ctx: Context): Type = tp.phantomTopClass match {
-    case top: ClassInfo => top.prefix.select(tpnme.Any)
-    case _ => defn.AnyType
+  def topOf(tp: Type)(implicit ctx: Context): Type = {
+    val lattice = tp.phantomLatticeClass
+    if (lattice.exists) lattice.select(tpnme.Any)
+    else defn.AnyType
   }
 
-  def bottomOf(tp: Type)(implicit ctx: Context): Type = tp.phantomTopClass match {
-    case top: ClassInfo => top.prefix.select(tpnme.Nothing)
-    case _ => defn.NothingType
+  def bottomOf(tp: Type)(implicit ctx: Context): Type = {
+    val lattice = tp.phantomLatticeClass
+    if (lattice.exists) lattice.select(tpnme.Nothing)
+    else defn.NothingType
   }
 
   lazy val ErasedPhantomClass = ctx.requiredClass("dotty.runtime.ErasedPhantom")

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

@@ -232,35 +232,63 @@ object NameOps {
       }
     }
 
-    /** Is a synthetic function name
+    /** Return the function arity
      *    - N for FunctionN
      *    - N for ImplicitFunctionN
-      *   - (-1) otherwise
+     *    - N for PhantomFunctionM where N is the length of M
+     *    - N for ImplicitPhantomFunctionM where N is the length of M
+     *   - (-1) otherwise
      */
-    def functionArity: Int =
-      functionArityFor(tpnme.Function) max functionArityFor(tpnme.ImplicitFunction)
+    def functionArity(implicit ctx: Context): Int = phantomicity.arity
+
+    /** Checks and returns the phantomicity of the function */
+    def phantomicity(implicit ctx: Context): Phantomicity = {
+      val arity = functionArityFor(tpnme.Function) max functionArityFor(tpnme.ImplicitFunction)
+      if (arity >= 0) Phantomicity.noPhantoms(arity)
+      else {
+        val phantomicity = phantomFunctionPhantomicity(tpnme.PhantomFunction)
+        if (phantomicity.isValid) phantomicity
+        else phantomFunctionPhantomicity(tpnme.ImplicitPhantomFunction)
+      }
+    }
 
     /** Is a function name
      *    - FunctionN for N >= 0
      *    - ImplicitFunctionN for N >= 0
+     *    - PhantomFunctionM for a valid M
+     *    - ImplicitPhantomFunctionM for a valid M
      *    - false otherwise
      */
-    def isFunction: Boolean = functionArity >= 0
+    def isFunction(implicit ctx: Context): Boolean = functionArity >= 0
 
     /** Is a implicit function name
      *    - ImplicitFunctionN for N >= 0
+     *    - ImplicitPhantomFunctionM for a valid M
+     *    - false otherwise
+     */
+    def isImplicitFunction: Boolean = {
+      functionArityFor(tpnme.ImplicitFunction) >= 0 ||
+        phantomFunctionPhantomicity(tpnme.ImplicitPhantomFunction).isValid
+    }
+
+    /** Is a phantom function name
+     *    - PhantomFunctionM for a valid M
+     *    - ImplicitPhantomFunctionM for a valid M
      *    - false otherwise
      */
-    def isImplicitFunction: Boolean = functionArityFor(tpnme.ImplicitFunction) >= 0
+    def isPhantomFunction(implicit ctx: Context): Boolean = phantomicity.hasPhantoms
 
     /** Is a synthetic function name
      *    - FunctionN for N > 22
      *    - ImplicitFunctionN for N >= 0
+     *    - PhantomFunctionM for a valid M
+     *    - ImplicitPhantomFunctionM for a valid M
      *    - false otherwise
      */
-    def isSyntheticFunction: Boolean = {
-      functionArityFor(tpnme.Function) > MaxImplementedFunctionArity ||
-        functionArityFor(tpnme.ImplicitFunction) >= 0
+    def isSyntheticFunction(implicit ctx: Context): Boolean = {
+      val p = phantomicity
+      if (name.startsWith(tpnme.Function)) p.arity > MaxImplementedFunctionArity
+      else p.isValid
     }
 
     /** Parsed function arity for function with some specific prefix */
@@ -271,6 +299,12 @@ object NameOps {
       else -1
     }
 
+    /** Parsed function phantomicity for function with some specific prefix */
+    private def phantomFunctionPhantomicity(prefix: Name): Phantomicity = {
+      lazy val p = Phantomicity.from(name.toString.substring(prefix.length))
+      if (name.startsWith(prefix) && p.isValid) p
+      else Phantomicity.invalid
+    }
 
     /** The number of hops specified in an outer-select name */
     def outerSelectHops: Int = {