fixed ElimObjectAny phase: backend now not seeing ObjectAny; adding MoveReifiedParam phase

Author: AragornXu

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -113,6 +113,7 @@ class Compiler {
  List(new AddReifiedTypes) :: // Add reified type parameters
  List(new ErasurePreservation) :: //
  List(new Erasure) :: // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
+ List(new MoveReifiedParams) :: // Move the reified value parameters to the end of parameter list
  List(new ElimObjectAny, // Eliminate ObjcetAny to Object
  new ElimErasedValueType, // Expand erased value types to their underlying implementation types
  new PureStats, // Remove pure stats from blocks

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

@@ -47,7 +47,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  override def prepareForTemplate(tree: Template)(using Context): Context = 
  val cls = ctx.owner.asClass
  if (cls.typeParams.nonEmpty){
- println(s"PrepareForTemplate for class ${cls.name} with type params: ${cls.typeParams.map(_.name)}")
+ if DEBUG then println(s"AddReifiedTypes: PrepareForTemplate for class ${cls.name} with type params: ${cls.typeParams.map(_.name)}")
  val fields = cls.typeParams.map { tparam => 
  val reifiedName = termName(s"reifiedField$$${tparam.name}")
  val reifiedSym = newSymbol(cls, reifiedName, Flags.Private | Flags.Local | Flags.Mutable, defn.ReifiedValueType)
@@ -65,7 +65,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val newFields = fieldsMap.map { case (name, sym) => 
  ValDef(sym.asTerm)
  }.toList
- println(s"TransformTemplate for class ${cls.name}, adding reified fields: ${newFields.map(_.name)}")
+ if DEBUG then println(s"TransformTemplate for class ${cls.name}, adding reified fields: ${newFields.map(_.name)}")
 
  val constr = tree.constr
  val allParams = constr.paramss.flatten
@@ -91,7 +91,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val cls = sym.owner.asClass
  val reifiedNames = cls.typeParams.map(tparam => termName(s"reifiedField$$${tparam.name}"))
  val reifiedTypes = reifiedNames.map(_ => defn.ReifiedValueType)
- println(s"TransformInfo for constructor ${sym.name} of class ${cls.name}, adding reified params: ${reifiedNames}")
+ if DEBUG then println(s"AddReifiedTypes: TransformInfo for constructor ${sym.name} of class ${cls.name}, adding reified params: ${reifiedNames}")
  addParamsToMethod(tp, reifiedNames, reifiedTypes)
  } else addReifiedParams(tp)
  //println(s"Transforming method info for ${sym.name}, from: ${tp.show} to: ${res.show}")
@@ -163,7 +163,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  tparams.asInstanceOf[List[TypeDef]]
  }.flatten
  if (typeParams.nonEmpty) {
- if DEBUG then println(s"PrepareForDefDef for tree.show: ${tree.show}" +
+ if DEBUG then println(s"AddReifiedTypes: PrepareForDefDef for tree.show: ${tree.show}" +
  s" tree: ${tree}" +
  s" with type params: ${typeParams.map(_.name)}")
  val typeParamMap = typeParams.map{tparam => 
@@ -187,7 +187,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val newParamDefs = newParamSyms.map(sym => ValDef(sym.asTerm))
 
  val newParamss = tree.paramss :+ newParamDefs
- println(s"TransformDefDef for constructor ${sym.name} of class ${cls.name}, adding reified params: ${newParamDefs.map(_.name)}")
+ if DEBUG then println(s"AddReifiedTypes: TransformDefDef for constructor ${sym.name} of class ${cls.name}, adding reified params: ${newParamDefs.map(_.name)}")
 
  return cpy.DefDef(tree)(paramss = newParamss.asInstanceOf[List[ParamClause]])
  }
@@ -208,14 +208,14 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  case vparams: List[?] =>
  newParamss = newParamss :+ clause.asInstanceOf[ParamClause]
  if (typeParams.nonEmpty) {
- if DEBUG then println(s"TransformDefDef for tree: ${tree.show} Adding reified value at end for method ${sym.name} with type params: ${typeParams.map(_.name)}")
+ if DEBUG then println(s"AddReifiedTypes: TransformDefDef for tree: ${tree.show} Adding reified value at end for method ${sym.name} with type params: ${typeParams.map(_.name)}")
  newParamss = newParamss :+ createReifiedClause(sym, typeParams)
  typeParams = Nil
  }
  }
  }
  if (typeParams.nonEmpty) {
- if DEBUG then println(s"TransformDefDef for tree: ${tree.show} Adding reified value at end for method ${sym.name} with type params: ${typeParams.map(_.name)}")
+ if DEBUG then println(s"AddReifiedTypes: TransformDefDef for tree: ${tree.show} Adding reified value at end for method ${sym.name} with type params: ${typeParams.map(_.name)}")
  newParamss = newParamss :+ createReifiedClause(sym, typeParams)
  }
  cpy.DefDef(tree)(paramss = newParamss)
@@ -230,15 +230,15 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  if (map.contains(tparam.name)){
  ValDef(map(tparam.name).asTerm)
  } else {
- report.error(s"ERROR: createReifiedClause: no reified sym found for type param ${tparam.name} in method ${sym.name}")
+ report.error(s"AddReifiedTypes: ERROR: createReifiedClause: no reified sym found for type param ${tparam.name} in method ${sym.name}")
  val reifiedName = termName(s"reified$$${tparam.name}")
  val reifiedSym = newSymbol(sym, reifiedName, Flags.Param, defn.ReifiedValueType)
  ValDef(reifiedSym.asTerm)
  }
  }
  } else {
- if DEBUG then println(s"reifiedSyms keys: ${reifiedSyms.keys.map(_.name)}")
- report.error(s"ERROR: createReifiedClause: no reified syms found for method ${sym.name}")
+ if DEBUG then println(s"AddReifiedTypes: reifiedSyms keys: ${reifiedSyms.keys.map(_.name)}")
+ report.error(s"AddReifiedTypes: ERROR: createReifiedClause: no reified syms found for method ${sym.name}")
  Nil
  }
  }
@@ -249,21 +249,21 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val sym = getCallSymbol(fun)
 
  if (sym.isConstructor) {
- println(s"TransformApply Constructor call: tree: $tree, ${tree.show}")
+ println(s"AddReifiedTypes: TransformApply Constructor call: tree: $tree, ${tree.show}")
  val isReified = tree.tpe.widen match {
  case mt: MethodType => 
  // println(s"TransformApply Constructor call: method type: ${mt.paramNames}")
  mt.paramNames.nonEmpty && mt.paramNames.head.toString.startsWith("reifiedField$")
  case _ => false
  }
  if (isReified) {
- println(s"TransformApply Constructor: need to add reified args to constructor call: ${tree.show}")
+ if DEBUG then println(s"AddReifiedTypes: TransformApply Constructor: need to add reified args to constructor call: ${tree.show}")
  var current = fun
  while (current.isInstanceOf[Apply]) current = current.asInstanceOf[Apply].fun
 
  val reifiedArgs = collectReifiedArgs(current)
  if (reifiedArgs.nonEmpty) {
- println(s"TransformApply Constructor: appending args ${reifiedArgs.map(_.show)}")
+ if DEBUG then println(s"AddReifiedTypes: TransformApply Constructor: appending args ${reifiedArgs.map(_.show)}")
  val reifiedParamNames = reifiedArgs.map(_ => termName("reified"))
  val reifiedParamTypes = reifiedArgs.map(_ => defn.ReifiedValueType)
 
@@ -276,7 +276,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val funType = fun.tpe.widen
  val resType = funType match {
  case mt: MethodType => 
- if DEBUG then println(s"TransformApply tree type: ${tree.tpe.show}, method type: ${mt.resType.show}")
+ if DEBUG then println(s"AddReifiedTypes: TransformApply tree type: ${tree.tpe.show}, method type: ${mt.resType.show}")
  mt.resType
  case _ => tree.tpe
  }
@@ -287,7 +287,7 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  case mt: MethodType => mt.resType
  case _ => resType
  }
- if DEBUG then println(s"Transforming Apply: ${tree.show}, fun type: ${funType.show}, res type: ${resType.show}, with reified args: ${reifiedArgs.map(_.show)}")
+ if DEBUG then println(s"AddReifiedTypes: Transforming Apply: ${tree.show}, fun type: ${funType.show}, res type: ${resType.show}, with reified args: ${reifiedArgs.map(_.show)}")
  Apply(innerApply, reifiedArgs).withType(outerResType)
  } else tree
  }
@@ -335,8 +335,8 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  case Some(sym) => 
  ref(sym)
  case None => 
- println(s"should not be here! ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${ctx.owner.name}");
- report.error(s"ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${ctx.owner.name}")
+ println(s"AddReifiedTypes: should not be here! ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${ctx.owner.name}");
+ report.error(s"AddReifiedTypes: ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${ctx.owner.name}")
  Literal(Constant(0.toByte)).withType(defn.ReifiedValueType)
  }
  case tr: TypeRef => {
@@ -349,8 +349,8 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val fieldSym = classFieldSyms(paramOwner)(paramName)
  This(paramOwner.asClass).select(fieldSym)
  } else {
- println(s"should not be here! ERROR: createReifiedValue: no reified field found for class type param ${paramName} in class ${paramOwner.name}");
- report.error(s"ERROR: createReifiedValue: no reified field found for class type param ${paramName} in class ${paramOwner.name}")
+ println(s"AddReifiedTypes: should not be here! ERROR: createReifiedValue: no reified field found for class type param ${paramName} in class ${paramOwner.name}");
+ report.error(s"AddReifiedTypes: ERROR: createReifiedValue: no reified field found for class type param ${paramName} in class ${paramOwner.name}")
  Literal(Constant(0.toByte)).withType(defn.ReifiedValueType)
  }
  }
@@ -360,8 +360,8 @@ class AddReifiedTypes extends MiniPhase with InfoTransformer {
  val sym = reifiedSyms(paramOwner)(paramName)
  ref(sym)
  else {
- println(s"should not be here! ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${paramOwner.name}");
- report.error(s"ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${paramOwner.name}")
+ println(s"AddReifiedTypes: should not be here! ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${paramOwner.name}");
+ report.error(s"AddReifiedTypes: ERROR: createReifiedValue: no reified sym found for type param ${paramName} in owner ${paramOwner.name}")
  Literal(Constant(0.toByte)).withType(defn.ReifiedValueType)
  }
  else

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

@@ -37,12 +37,58 @@ class ElimObjectAny extends MiniPhase with InfoTransformer{
  val newType = elimObjectAny(tree.tpe)
  if (newType ne tree.tpe) then tree.withType(newType)
  else tree
- // def changeObjectAnyToObject(tp: Type)(using Context): Type = {
- // tp match 
- // case tr: TypeRef if tr.symbol == defn.ObjectAnySymbol =>
- // defn.ObjectType
- // case _ => tp
- // }
+ 
+ override def transformApply(tree: Apply)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformSelect(tree: Select)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformIdent(tree: Ident)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformTyped(tree: Typed)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformBlock(tree: Block)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformIf(tree: If)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformTypeApply(tree: TypeApply)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformLiteral(tree: Literal)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformThis(tree: This)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformNew(tree: New)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformSuper(tree: Super)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformMatch(tree: Match)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformTry(tree: Try)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformReturn(tree: Return)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformSeqLiteral(tree: SeqLiteral)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
+ override def transformInlined(tree: Inlined)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+ 
+ override def transformAssign(tree: Assign)(using Context): Tree =
+ tree.withType(elimObjectAny(tree.tpe))
+
 }
 
 object ElimObjectAny {

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

@@ -0,0 +1,89 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.core.DenotTransformers.InfoTransformer
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.Types.*
+import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.transform.ErasurePreservation.*
+import dotty.tools.dotc.core.Names.*
+import dotty.tools.dotc.core.Phases.*
+
+class MoveReifiedParams extends MiniPhase with InfoTransformer{
+ import tpd.*
+ override def phaseName: String = "moveReifiedParams"
+ override def description: String = "move reified parameters to the end of the parameter list"
+
+ final val DEBUG = false
+
+ override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+ case mt: MethodType if sym.is(Flags.Method)=>
+ val zipped = mt.paramNames.zip(mt.paramInfos)
+ val (reified, normal) = zipped.partition((name, _) => name.toString.startsWith("reified$"))
+ val newNames = normal.map(_._1) ++ reified.map(_._1)
+ val newInfos = normal.map(_._2) ++ reified.map(_._2)
+
+ if (reified.nonEmpty){
+ if DEBUG then println(s"MoveReifiedParams: transformInfo : Reordering method parameters for ${sym} from ${mt.paramNames} to ${newNames}")
+ mt.derivedLambdaType(newNames, newInfos, mt.resType)
+ } else tp
+ case _ => tp
+ }
+
+ override def transformDefDef(tree: DefDef)(using Context): Tree = {
+ val sym = tree.symbol
+ val allParams = tree.paramss.flatten
+
+ val (reifiedParams, normalParams) = allParams.partition(_.name.toString.startsWith("reified$"))
+
+ if (reifiedParams.nonEmpty) {
+ val newParams = normalParams ++ reifiedParams
+ 
+ val newTree = cpy.DefDef(tree)(paramss = List(newParams.asInstanceOf[ParamClause]))
+ 
+ // reorder MethodParameterReturnType attachment
+ if (tree.hasAttachment(MethodParameterReturnType)) {
+ val (count, paramTypes, retType) = tree.attachment(MethodParameterReturnType)
+ val zipped = allParams.zip(paramTypes)
+ val (reifiedT, normalT) = zipped.partition(_._1.name.toString.startsWith("reified$"))
+ val newParamTypes = normalT.map(_._2) ++ reifiedT.map(_._2)
+ 
+ if DEBUG then println(s"MoveReifiedParams: transformDefDef: old attachment: ${tree.attachment(MethodParameterReturnType)}, new attachment: ${(count, newParamTypes, retType)}")
+ newTree.putAttachment(MethodParameterReturnType, (count, newParamTypes, retType))
+ }
+ newTree
+ } else tree
+ }
+
+ override def transformApply(tree: Apply)(using Context): Tree = 
+ val sym = tree.fun.symbol
+ if (sym.is(Flags.Method)) {
+ // Collect ALL parameter names from the potentially curried/generic type
+ val allParamNames = atPhase(erasurePhase) {
+ collectParamNames(sym.info)
+ }
+
+ val args = tree.args
+ // Now we can compare the full flattened argument list with the full parameter name list
+ if (args.length == allParamNames.length) {
+ val zipped = args.zip(allParamNames)
+ val (reifiedArgs, normalArgs) = zipped.partition(_._2.toString.startsWith("reified$"))
+ 
+ if (reifiedArgs.nonEmpty) {
+ val newArgs = normalArgs.map(_._1) ++ reifiedArgs.map(_._1)
+ if DEBUG then println(s"MoveReifiedParams: transformApply: Reordering method arguments for ${sym} from\n" +
+ s" ${args.map(_.show)}\n" +
+ s" to ${newArgs.map(_.show)}")
+ cpy.Apply(tree)(tree.fun, newArgs)
+ } else tree
+ } else tree
+ } else tree
+
+ def collectParamNames(tp: Type)(using Context): List[Name] = tp match {
+ case pt: PolyType => collectParamNames(pt.resType)
+ case mt: MethodType => mt.paramNames ++ collectParamNames(mt.resType)
+ case _ => Nil
+ }
+}