added hints for NEW

Author: AragornXu

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -6,6 +6,7 @@ import scala.language.unsafeNulls
 
 import scala.annotation.{switch, tailrec}
 import scala.collection.mutable.SortedMap
+import scala.jdk.CollectionConverters.*
 
 import scala.tools.asm
 import scala.tools.asm.{Handle, Opcodes}
@@ -781,6 +782,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         // we have to 'simulate' it by DUPlicating the freshly created
         // instance (on JVM, <init> methods return VOID).
         case Apply(fun @ DesugaredSelect(New(tpt), nme.CONSTRUCTOR), args) =>
+          println(s"DEBUG: New(tpt = $tpt) at ${app.span}")
           val ctor = fun.symbol
           assert(ctor.isClassConstructor, s"'new' call to non-constructor: ${ctor.name}")
 
@@ -793,13 +795,19 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
             case rt: ClassBType =>
               assert(classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.showFullName} is different from $rt")
-              mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName)
+              val retType = app.getAttachment(InvokeReturnType)
+              val instrType = fun.getAttachment(InstructionTypeArguments)
+              val instrJType = instrType.getOrElse(Nil).map(bc.toJTypeA).asJava
+              // println(s"NEW with retType = $retType and instrType = $instrType")
+              mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName, instrJType)
               bc dup generatedType
               stack.push(rt)
               stack.push(rt)
               genLoadArguments(args, paramTKs(app))
               stack.pop(2)
-              genCallMethod(ctor, InvokeStyle.Special, app.span)
+              genCallMethod(ctor, InvokeStyle.Special, app.span, 
+                invokeReturnType = retType,
+                instrTypeArgs = instrType)
 
             case _ =>
               abort(s"Cannot instantiate $tpt of kind: $generatedType")
@@ -1457,20 +1465,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           val staticDesc = MethodBType(ownerBType :: bmType.argumentTypes, bmType.returnType).descriptor
           val staticName = traitSuperAccessorName(method)
           bc.invokestatic(receiverName, staticName, staticDesc, isInterface)
-          // bc.invokestatic(receiverName, staticName, staticDesc, isInterface, invokeReturnType, instrTypeArgs)
         } else {
           bc.invokespecial(receiverName, jname, mdescr, isInterface)
-          // bc.invokespecial(receiverName, jname, mdescr, isInterface, invokeReturnType, instrTypeArgs)
         }
       } else {
         val opc = style match {
           case Static => Opcodes.INVOKESTATIC
           case Special => Opcodes.INVOKESPECIAL
           case Virtual => if (isInterface) Opcodes.INVOKEINTERFACE else Opcodes.INVOKEVIRTUAL
         }
-        // println("genCallMethod" + method.show + " : " + method.getAnnotation(defn.ErasurePreservationAnnot))
         bc.emitInvoke(opc, receiverName, jname, mdescr, isInterface, invokeReturnType, instrTypeArgs)
-        // bc.emitInvoke(opc, receiverName, jname, mdescr, isInterface, invokeReturnType, instrTypeArgs)
       }
 
       bmType.returnType

compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala

@@ -452,6 +452,7 @@ trait BCodeIdiomatic {
 
     def emitInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean,
                    invokeReturnType : Option[dotty.tools.dotc.transform.TypeB] = None, instrTypeArgs : Option[List[dotty.tools.dotc.transform.TypeA]] = None): Unit = {
+      // println(s"emitInvoke $opcode $owner $name $desc itf=$itf invokeReturnType=$invokeReturnType instrTypeArgs=$instrTypeArgs")
       val node = new MethodInsnNode(opcode, owner, name, desc, itf)
       jmethod.instructions.add(node)
       invokeReturnType match {

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -401,6 +401,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
        *  backend emits them as static).
        *  No code is needed for this module symbol.
        */
+      // println("for class " + claszSymbol + " adding fields:")
+      // println("has methods:" + claszSymbol.info.decls.filter(p => p.is(Method)).toList)
       for (f <- claszSymbol.info.decls.filter(p => p.isTerm && !p.is(Method))) {
         val javagensig = getGenericSignature(f, claszSymbol)
         val flags = javaFieldFlags(f)
@@ -416,6 +418,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
           null // no initial value
         )
         cnode.fields.add(jfield)
+        // println("Adding field:" + f + " to " + claszSymbol + "with annotations " + f.annotations)
         emitAnnotations(jfield, f.annotations)
       }
 
@@ -714,7 +717,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
      * must-single-thread
      */
     def initJMethod(flags: Int, params: List[Symbol], cnt: Int, paramType: List[dotty.tools.dotc.transform.TypeB], retType : dotty.tools.dotc.transform.TypeB): Unit = {
-
+      // println(s"emitting method $methSymbol for class $claszSymbol with flags $flags params $params cnt $cnt retType $retType")
       val jgensig = getGenericSignature(methSymbol, claszSymbol)
       val (excs, others) = methSymbol.annotations.partition(_.symbol eq defn.ThrowsAnnot)
       val thrownExceptions: List[String] = getExceptions(excs)
@@ -863,8 +866,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         case Some((paramCount, paramType, returnType)) => (paramCount, paramType, returnType)
         case _ => (0, List.empty[dotty.tools.dotc.transform.TypeB], dotty.tools.dotc.transform.TypeB.None)
       }
-      if (cnt != 0) println(s"GenBCode.genDefDef.initJMethod: ${methSymbol.show} ${methodDeclarationAttrs} " +
-        s"${cnt} ${paramType} ${retType}")
+      // println(s"GenBCode.genDefDef.initJMethod: ${methSymbol.show} ${methodDeclarationAttrs} " +
+      //   s"${cnt} ${paramType} ${retType}")
       initJMethod(flags, paramSyms, cnt, paramType, retType)
 
 

compiler/src/dotty/tools/backend/jvm/MethodNode1.java

@@ -31,11 +31,14 @@
 import scala.tools.asm.tree.LineNumberNode;
 import scala.tools.asm.tree.MethodNode;
 import scala.tools.asm.tree.AbstractInsnNode;
+import scala.tools.asm.tree.TypeInsnNode;
 /**
  * A subclass of {@link MethodNode} to customize the representation of
  * label nodes with {@link LabelNode1}.
  */
 public class MethodNode1 extends MethodNode {
+    private final boolean DEBUG = false;
+
     public Map<AbstractInsnNode, TypeHints.TypeB> invokeReturnTypeBs = new LinkedHashMap<>();
 
     public Map<AbstractInsnNode, List<TypeHints.TypeA>> instructionTypeArgTypeAs = new LinkedHashMap<>();
@@ -389,7 +392,7 @@ public boolean hasTypeHints(){
     public void setAttribtues(){
         if (!hasTypeHints()) return;
         genOffsetMap();
-        printOffsetMap();
+        if (DEBUG) printOffsetMap();
         List<TypeHints.TypeBHint> typeBHintList = new ArrayList<>();
         for (Map.Entry<AbstractInsnNode, TypeHints.TypeB> entry : invokeReturnTypeBs.entrySet()){
             AbstractInsnNode insn = entry.getKey();
@@ -435,4 +438,17 @@ protected LabelNode getLabelNode(Label label) {
         }
         return (LabelNode) label.info;
     }
+
+    public void visitTypeInsn(int opcode, String type, List<TypeHints.TypeA> instrTypeA){
+        if (opcode == Opcodes.NEW && instrTypeA.size() > 0){
+            if (DEBUG) System.out.println("visitTypeInsn NEW with instrTypeA = " + instrTypeA);
+            AbstractInsnNode node = new TypeInsnNode(opcode, type);
+            instructions.add(node);
+            if (instrTypeA != null){
+                instructionTypeArgTypeAs.put(node, instrTypeA);
+            }
+        } else {
+            visitTypeInsn(opcode, type);
+        }
+    }
 }