Add method attachments

Author: HarrisL2

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

@@ -1100,6 +1100,7 @@ class Definitions {
   @tu lazy val RetainsArgAnnot: ClassSymbol = requiredClass("scala.annotation.retainsArg")
   @tu lazy val PublicInBinaryAnnot: ClassSymbol = requiredClass("scala.annotation.publicInBinary")
   @tu lazy val WitnessNamesAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WitnessNames")
+  @tu lazy val ErasurePreservationAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasurePreservation")
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -27,12 +27,16 @@ import util.Chars.isOperatorPart
 import config.{Config, Feature}
 import config.Feature.sourceVersion
 import config.SourceVersion.*
+import reporting.*
+import dotty.tools.dotc.core.Decorators.i
 
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
 import cc.*
 import dotty.tools.dotc.parsing.JavaParsers
 import dotty.tools.dotc.transform.TreeExtractors.BinaryOp
+import dotty.tools.dotc.transform.InstructionTypeArguments
+import dotty.tools.dotc.transform.InvokeReturnType
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
@@ -462,7 +466,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
       toTextLocal(expr) ~ "." ~ selectorsText
 
-    tree match {
+    (if tree.hasAttachment(InvokeReturnType) then Str("InvokeReturnType("+tree.attachment(InvokeReturnType).toString + ") ") else Str("")) ~
+    (if tree.hasAttachment(InstructionTypeArguments) then Str("InstructionTypeArguments("+tree.attachment(InstructionTypeArguments).toString + ") ") else Str("")) ~
+    (tree match {
       case id: Trees.SearchFailureIdent[?] =>
         tree.typeOpt match {
           case reason: Implicits.SearchFailureType =>
@@ -850,7 +856,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(pname) ~ " : " ~ toText(tycon) ~ (" as " ~ toText(ownName) `provided` !ownName.isEmpty)
       case _ =>
         tree.fallbackToText(this)
-    }
+    })
   }
 
   override protected def toTextCapturing(tp: Type, refs: GeneralCaptureSet, boxText: Text): Text = tp match

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

@@ -18,42 +18,87 @@ import typer.NoChecking
 import ast.{tpd, untpd}
 import reporting.*
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.util.Property
 
-class ErasurePreservation extends MiniPhase {
+class ErasurePreservation extends MiniPhase with InfoTransformer {
 
   override def phaseName: String = ErasurePreservation.name
 
   override def description: String = ErasurePreservation.description
 
-  override def transformDefDef(tree: tpd.DefDef)(using Context): tpd.Tree =
-    val sym = tree.symbol
-    sym.info match
+  def toTypeA(tp: Type)(using Context): TypeA = trace(s"toTypeA ${tp}") {tp match
+    case tpr: TypeParamRef => TypeA.M(tpr.paramNum)
+    case tr: TypeRef =>
+      // println(tr.symbol.owner.paramSymss)
+      if tr.isRef(defn.IntClass) then TypeA.Int else
+      if tr.symbol.isTypeParam then
+        val ind = tr.symbol.owner.paramSymss.head.indexWhere(tr.isRef(_))
+        if ind != -1 then TypeA.M(ind)
+        else TypeA.Ref
+      else TypeA.Ref
+    case _ => assert(false)
+  }
+
+
+  def toTypeB(tp: Type)(using Context): TypeB = tp match
+    case tpr: TypeParamRef => TypeB.M(tpr.paramNum)
+    case _ => TypeB.None
+
+  def toReturnTypeB(tp: Type)(using Context): TypeB = tp match
+    case tr: TypeRef =>
+      // println(tr.symbol.owner.paramSymss)
+      if tr.symbol.isTypeParam then
+        val ind = tr.symbol.owner.paramSymss.head.indexWhere(tr.isRef(_))
+        if ind != -1 then TypeB.M(ind)
+        else TypeB.None
+      else TypeB.None
+    case _ => TypeB.None
+
+
+  override def transformInfo(tp: Type, sym: Symbol)(using Context): Type =
+    tp match
         case pt: PolyType =>
-          def toTypeB(tp: Type): TypeB = tp match
-            case tpr: TypeParamRef => TypeB.M(tpr.paramNum)
-            case _ => TypeB.None
           pt.resType match
             case mt: MethodType =>
               sym.addAnnotation(ErasedInfo(pt.paramInfos.size, mt.paramInfos.map(toTypeB), toTypeB(mt.resType)))
             case other =>
               sym.addAnnotation(ErasedInfo(pt.paramInfos.size, Nil, toTypeB(other.widenExpr)))
         case _ => ()
+    tp
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    tree.putAttachment(InvokeReturnType, toReturnTypeB(tree.tpe))
     tree
+
+  override def transformTypeApply(tree: tpd.TypeApply)(using Context): tpd.Tree =
+    val args = tree.args.map(_.tpe).map(toTypeA)
+    tree.fun.putAttachment(InstructionTypeArguments, args) // Pattern match args based on their types
+    tree
+
 }
 
 object ErasurePreservation {
   val name: String = "erasure preservation"
   val description: String = "preserve information in annotations before erasure"
 }
 
+enum TypeA:
+  case Int
+  case M(x: Int)
+  case K(x: Int)
+  case Ref
+
 enum TypeB:
   case None
   case M(x: Int)
 // case class TypeB(tp: Type)
 
+object InstructionTypeArguments extends Property.StickyKey[List[TypeA]]
+object InvokeReturnType extends Property.StickyKey[TypeB]
+
 class ErasedInfo(paramCount: Int, paramType: List[TypeB], returnType: TypeB) extends Annotation {
   override def tree(using Context) =
-    tpd.New(defn.SourceFileAnnot.typeRef,
+    tpd.New(defn.ErasurePreservationAnnot.typeRef,
             List(tpd.Literal(Constant(toString))))
 
   override def toString =

library/src/scala/annotation/internal/ErasurePreservation.scala

@@ -0,0 +1,7 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+class ErasurePreservation(path: String) extends Annotation {
+
+}