init adding reified values to methods

Author: AragornXu

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

@@ -109,8 +109,9 @@ class Compiler {
          new ParamForwarding,        // Add forwarders for aliases of superclass parameters
          new TupleOptimizations,     // Optimize generic operations on tuples
          new LetOverApply,           // Lift blocks from receivers of applications
-         new ArrayConstructors,      // Intercept creation of (non-generic) arrays and intrinsify.
-         new ErasurePreservation) :: //
+         new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
+    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 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

@@ -0,0 +1,103 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.DenotTransformers.*
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import core.Contexts.Context
+import core.Types.*
+import core.Names.*
+import core.Symbols.*
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Constants.*
+
+class AddReifiedTypes extends MiniPhase with InfoTransformer {
+    import ast.tpd.*
+    
+    override def phaseName: String = "addReifiedTypes"
+    override def description: String = "add reified type values to methods"
+
+    override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+        case pt: PolyType =>
+            pt.derivedLambdaType(
+                pt.paramNames,
+                pt.paramInfos,
+                addReifiedParams(pt.resType, pt.paramNames)
+            )
+        case _ => tp
+    }
+
+    def addReifiedParams(tp: Type, typeParamNames: List[Name])(using Context): Type = tp match {
+        case mt: MethodType =>
+            val newParamNames = typeParamNames.map(name => termName(s"reified_$name"))
+            val newParamTypes = newParamNames.map(_ => defn.AnyType)
+            mt.derivedLambdaType(
+                mt.paramNames ++ newParamNames,
+                mt.paramInfos ++ newParamTypes,
+                mt.resultType
+            )
+        case pt: PolyType =>
+            pt.derivedLambdaType(
+                pt.paramNames,
+                pt.paramInfos,
+                addReifiedParams(pt.resType, typeParamNames)
+            )
+        case _ => tp
+    }
+    
+    override def transformDefDef(tree: DefDef)(using Context): Tree = {
+        val sym = tree.symbol
+        val typeParams = tree.paramss.collectFirst {
+            case tparams: List[?] if tparams.nonEmpty && tparams.head.isInstanceOf[TypeDef] =>
+                tparams.asInstanceOf[List[TypeDef]]
+        }.getOrElse(Nil)
+
+        if (typeParams.nonEmpty) {
+            val newParamDefs = typeParams.map { tparam =>
+                val paramName = termName(s"reified_${tparam.name}")
+                val paramSym = newSymbol(
+                    sym,
+                    paramName,
+                    Flags.Param,
+                    defn.AnyType
+                ).asTerm
+                ValDef(paramSym)
+            }
+            
+            var added = false
+            val newParamss = tree.paramss.map { clause =>
+                val isTypeClause = clause.nonEmpty && clause.head.isInstanceOf[TypeDef]
+                if (!isTypeClause && !added) {
+                    added = true
+                    val newClause: ParamClause = clause.asInstanceOf[List[ValDef]] ++ newParamDefs
+                    newClause
+                } else {
+                    clause
+                }
+            }
+            
+            if (added) cpy.DefDef(tree)(paramss = newParamss)
+            else tree
+        } else tree
+    }
+
+    override def transformApply(tree: Apply)(using Context): Tree = {
+        val sym = tree.fun.symbol
+        if (sym.exists && sym.is(Flags.Method) && sym.info.isInstanceOf[PolyType]) {
+            val reifiedArgs = tree.fun match {
+                case TypeApply(_, targs) =>
+                    targs.map(targ => createReifiedValue(targ.tpe))
+                case _ =>
+                    val poly = sym.info.asInstanceOf[PolyType]
+                    poly.paramNames.map(_ => createReifiedValue(defn.AnyType))
+            }
+            cpy.Apply(tree)(tree.fun, tree.args ++ reifiedArgs)
+        } else {
+            tree
+        }
+    }
+    
+    def createReifiedValue(tpe: Type)(using Context): Tree = {
+        Literal(Constant(()))
+    }
+}