experiment with TypeOps.refineUsingParent

Author: bishabosha

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

@@ -872,23 +872,36 @@ object TypeOps:
 
   end healPrefix
 
+  def hasPathPrefix(tpe: Type): Boolean =
+
+    def inner(pre: Type): Boolean = pre match
+      case pre: TermRef       => inner(pre.prefix)
+      case pre: SingletonType => true
+      case NoPrefix           => true
+      case _ => false
+
+    appliedTypePrefix(tpe) match
+      case Some(pre) => inner(pre)
+      case _ => false
+
+  end hasPathPrefix
+
   /** lift the prefix of an applied type, without normalisation or forcing */
-  def appliedTypePrefix(tpe: Type)(using Context): Option[Type] =
-    tpe match
-      case tpe: NamedType        => Some(tpe.prefix)
-      case tpe: ThisType         => appliedTypePrefix(tpe.tref)
-      case tpe: AppliedType      => appliedTypePrefix(tpe.tycon)
-      case tpe: AnnotatedType    => appliedTypePrefix(tpe.parent) // TODO: test
-      case tpe: AndOrType        => Some(NoPrefix) // TODO: test
-      case _ =>
-        // ignore HKTypeLambda/TypeBounds
-        // what do do about
-        // - MatchType        -- will this occur or will it be reduced?
-        // - TypeParamRef     -- likely collapse to bounds?
-        // - TypeVar/ExprType -- when can this occur
-        // - RecThis          -- what is the prefix of this
-        // - RefinedOrRecType -- do we need to refine the children?
-        // - AnnotatedType    -- do we need to annotate the children?
-        None
+  def appliedTypePrefix(tpe: Type): Option[Type] = tpe match
+    case tpe: NamedType        => Some(tpe.prefix)
+    case tpe: ThisType         => appliedTypePrefix(tpe.tref)
+    case tpe: AppliedType      => appliedTypePrefix(tpe.tycon)
+    case tpe: AnnotatedType    => appliedTypePrefix(tpe.parent) // TODO: test
+    case tpe: AndOrType        => Some(NoPrefix) // TODO: test
+    case _ =>
+      // ignore HKTypeLambda/TypeBounds
+      // what do do about
+      // - MatchType        -- will this occur or will it be reduced?
+      // - TypeParamRef     -- likely collapse to bounds?
+      // - TypeVar/ExprType -- when can this occur
+      // - RecThis          -- what is the prefix of this
+      // - RefinedOrRecType -- do we need to refine the children?
+      // - AnnotatedType    -- do we need to annotate the children?
+      None
 
 end TypeOps

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -28,6 +28,7 @@ object SyntheticMembers {
   val ExtendsSumMirror: Property.StickyKey[Unit] = new Property.StickyKey
 
   val SubstPrefix: Property.StickyKey[Type] = new Property.StickyKey
+  val OriginalMirroredType: Property.StickyKey[Type] = new Property.StickyKey
 }
 
 /** Synthetic method implementations for case classes, case objects,
@@ -473,8 +474,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  type MirroredMonoType = C[?]
    *  ```
    */
-  def fromProductBody(caseClass: Symbol, param: Tree, pre: Type)(using Context): Tree = {
-    val (classRef0, methTpe) =
+  def fromProductBody(caseClass: Symbol, param: Tree, pre: Type, mirroredType: Option[Type])(using Context): Tree = {
+    val (classRef, methTpe) =
       caseClass.primaryConstructor.info match {
         case tl: PolyType =>
           val (tl1, tpts) = constrained(tl, untpd.EmptyTree, alwaysAddTypeVars = true)
@@ -487,7 +488,6 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case methTpe =>
           (caseClass.typeRef, methTpe)
       }
-    val classRef = TypeOps.healPrefix(classRef0, pre).getOrElse(classRef0)
     methTpe match {
       case methTpe: MethodType =>
         val elems =
@@ -517,13 +517,18 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  a wildcard for each type parameter. The normalized type of an object
    *  O is O.type.
    */
-  def ordinalBody(cls: Symbol, param: Tree, pre: Type)(using Context): Tree =
+  def ordinalBody(cls: Symbol, param: Tree, pre: Type, mirroredType: Option[Type])(using Context): Tree =
     if (cls.is(Enum)) param.select(nme.ordinal).ensureApplied
     else {
       val cases =
         for ((child, idx) <- cls.children.zipWithIndex) yield {
           val patType0 = if child.isTerm then child.termRef else child.rawTypeRef
           val patType = TypeOps.healPrefix(patType0, pre).getOrElse(patType0)
+          // val patType = mirroredType.map { tpe =>
+          //   TypeOps.refineUsingParent(tpe, child)
+          // }.getOrElse {
+          //   if child.isTerm then child.reachableTermRef else child.reachableRawTypeRef
+          // }
           val pat = Typed(untpd.Ident(nme.WILDCARD).withType(patType), TypeTree(patType))
           CaseDef(pat, EmptyTree, Literal(Constant(idx)))
         }
@@ -572,32 +577,33 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     }
     def makeSingletonMirror() =
       addParent(defn.Mirror_SingletonClass.typeRef)
-    def makeProductMirror(cls: Symbol, pre: Type) = {
+    def makeProductMirror(cls: Symbol, pre: Type, mirroredType: Option[Type]) = {
       addParent(defn.Mirror_ProductClass.typeRef)
       addMethod(nme.fromProduct, MethodType(defn.ProductClass.typeRef :: Nil, monoType.typeRef), cls,
-        fromProductBody(_, _, pre).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
+        fromProductBody(_, _, pre, mirroredType).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
     }
-    def makeSumMirror(cls: Symbol, pre: Type) = {
+    def makeSumMirror(cls: Symbol, pre: Type, mirroredType: Option[Type]) = {
       addParent(defn.Mirror_SumClass.typeRef)
       addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType), cls,
-        ordinalBody(_, _, pre))
+        ordinalBody(_, _, pre, mirroredType))
     }
 
     val pre = impl.removeAttachment(SubstPrefix).getOrElse(NoPrefix)
+    val mirroredType = impl.removeAttachment(OriginalMirroredType)
 
     if (clazz.is(Module)) {
       if (clazz.is(Case)) makeSingletonMirror()
-      else if (linked.isGenericProduct) makeProductMirror(linked, pre)
-      else if (linked.isGenericSum(clazz)) makeSumMirror(linked, pre)
+      else if (linked.isGenericProduct) makeProductMirror(linked, pre, mirroredType)
+      else if (linked.isGenericSum(clazz)) makeSumMirror(linked, pre, mirroredType)
       else if (linked.is(Sealed))
         derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum(clazz)}")
     }
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()
     else if (impl.removeAttachment(ExtendsProductMirror).isDefined)
-      makeProductMirror(monoType.typeRef.dealias.classSymbol, pre)
+      makeProductMirror(monoType.typeRef.dealias.classSymbol, pre, mirroredType)
     else if (impl.removeAttachment(ExtendsSumMirror).isDefined)
-      makeSumMirror(monoType.typeRef.dealias.classSymbol, pre)
+      makeSumMirror(monoType.typeRef.dealias.classSymbol, pre, mirroredType)
 
     cpy.Template(impl)(parents = newParents, body = newBody)
   }

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

@@ -176,7 +176,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   /** Create an anonymous class `new Object { type MirroredMonoType = ... }`
    *  and mark it with given attachment so that it is made into a mirror at PostTyper.
    */
-  private def anonymousMirror(monoType: Type, attachment: Property.StickyKey[Unit], substPrefix: Option[Type], span: Span)(using Context) =
+  private def anonymousMirror(monoType: Type, mirroredType: Type, attachment: Property.StickyKey[Unit], substPrefix: Option[Type], span: Span)(using Context) =
     if ctx.isAfterTyper then ctx.compilationUnit.needsMirrorSupport = true
     val monoTypeDef = untpd.TypeDef(tpnme.MirroredMonoType, untpd.TypeTree(monoType))
     var newImpl = untpd.Template(
@@ -185,7 +185,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       derived = Nil,
       self = EmptyValDef,
       body = monoTypeDef :: Nil
-    ).withAttachment(attachment, ())
+    ).withAttachment(attachment, ()).withAttachment(OriginalMirroredType, mirroredType)
 
     substPrefix match {
       case Some(pre) =>
@@ -236,6 +236,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     monoMap(mirroredType.resultType)
 
   private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): Tree =
+    // val pre = NoPrefix
     val pre = TypeOps.appliedTypePrefix(mirroredType) match
       case Some(pre) => pre
       case _         => return EmptyTree
@@ -280,13 +281,14 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
               .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
               .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
           val mirrorRef =
-            if (cls.is(Scala2x)) anonymousMirror(monoType, ExtendsProductMirror, Some(pre), span)
+            if (cls.is(Scala2x)) anonymousMirror(monoType, mirroredType, ExtendsProductMirror, Some(pre), span)
             else companionPath(mirroredType, span)
           mirrorRef.cast(mirrorType)
         else EmptyTree
   end productMirror
 
   private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): Tree =
+    // val pre = NoPrefix
     val pre = TypeOps.appliedTypePrefix(mirroredType) match
       case Some(pre) => pre
       case _         => return EmptyTree
@@ -332,7 +334,16 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       end solveInner
 
       def solve(sym: Symbol): Either[String, Type] =
-        TypeOps.healPrefix(solveInner(sym), pre)
+        TypeOps.healPrefix(solveInner(sym), pre) // TODO i13332 tests will break with refineUsingParent
+        // // it seems we may need to still do some substitution of ThisType
+        // // or else TASTy idempotency tests fail,
+        // // see tests/pos/anon-mirror-gen-this-a.scala
+        // val res = TypeOps.refineUsingParent(mirroredType, sym)
+        // report.echo(i"healed $sym with $mirroredType to $res [${res.toString}]")
+        // // if TypeOps.hasPathPrefix(res) then
+        // Right(res)
+        // // else
+        //   // Left("foo")
 
       val (errors, resolvedChildren) = cls.children.map(solve).partitionMap(identity)
       if errors.nonEmpty then
@@ -354,7 +365,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
               .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
         val mirrorRef =
           if useCompanion then companionPath(mirroredType, span)
-          else anonymousMirror(monoType, ExtendsSumMirror, Some(pre), span)
+          else anonymousMirror(monoType, mirroredType, ExtendsSumMirror, Some(pre), span)
         mirrorRef.cast(mirrorType)
     else EmptyTree
   end sumMirror