modified test case & make debug info cleaner

Author: AragornXu

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

@@ -405,6 +405,7 @@ public void setAttribtues(){
         }
         if (typeBHintList.size() != 0){
             this.invokeReturnTypeAttribute = new InvokeReturnType(typeBHintList.size(), typeBHintList);
+            System.out.println("invokeReturnTypeAttribute: " + invokeReturnTypeAttribute);
             visitAttribute(invokeReturnTypeAttribute);
         }
         List<TypeHints.TypeAHint> typeAHintList = new ArrayList<>();
@@ -421,6 +422,7 @@ public void setAttribtues(){
         }
         if (typeAHintList.size() != 0){
             this.instructionTypeArgumentsAttribute = new InstructionTypeArguments(typeAHintList);
+            System.out.println("instructionTypeArgumentsAttribute: " + instructionTypeArgumentsAttribute);
             visitAttribute(instructionTypeArgumentsAttribute);
         }
 

compiler/src/dotty/tools/backend/jvm/attributes/InstructionTypeArguments.java

@@ -65,4 +65,17 @@ public ByteVector write(ClassWriter cw, byte[] code, int codeLength, int maxStac
     public List<TypeHints.TypeAHint> getTypeArguments() {
         return typeArguments;
     }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("InstructionTypeArguments{");
+        for (TypeHints.TypeAHint typeHint : typeArguments) {
+            sb.append(typeHint.toString()).append(", ");
+        }
+        if (!typeArguments.isEmpty()) {
+            sb.setLength(sb.length() - 2);
+        }
+        sb.append("}");
+        return sb.toString();
+    }
 }

compiler/src/dotty/tools/backend/jvm/attributes/InvokeReturnType.java

@@ -73,4 +73,17 @@ public ByteVector write(ClassWriter cw, byte[] code, int codeLength, int maxStac
         return bv;
     }
 
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("InvokeReturnType{");
+        sb.append("typeList=[");
+        for (TypeHints.TypeBHint typeBHint : typeList) {
+            sb.append(typeBHint.toString()).append(", ");
+        }
+        if (!typeList.isEmpty()) {
+            sb.setLength(sb.length() - 2);
+        }
+        sb.append("]}");
+        return sb.toString();
+    }
 }

compiler/src/dotty/tools/backend/jvm/attributes/TypeHints.java

@@ -81,6 +81,21 @@ public int getBytecodeOffset() {
         public List<TypeA> getTypeList() {
             return typeList;
         }
+
+        @Override
+        public String toString() {
+            StringBuilder sb = new StringBuilder("TypeAHint{");
+            sb.append("bytecodeOffset=").append(bytecodeOffset);
+            sb.append(", typeList=[");
+            for (TypeA typeA : typeList) {
+                sb.append(typeA.toString()).append(", ");
+            }
+            if (!typeList.isEmpty()) {
+                sb.setLength(sb.length() - 2);
+            }
+            sb.append("]}");
+            return sb.toString();
+        }
     }
 
     public static class TypeB {
@@ -138,5 +153,13 @@ public int getBytecodeOffset() {
         public TypeB getTypeB() {
             return typeB;
         }
+
+        @Override
+        public String toString() {
+            return "TypeBHint{" +
+                            "bytecodeOffset=" + bytecodeOffset +
+                            ", typeB=" + typeB +
+                            '}';
+        }
     }
 }

tests/GenericMethod.scala

@@ -15,7 +15,6 @@ class GenericMethod {
   // @MethodParameterType: M0, M1
   // @MethodReturnType: M0
   def first[A, B](fst: A, snd: B): A = fst
-  override def toString: String = "Printing GenericMethod"
 }
 
 object testGenericMethod1{
@@ -24,18 +23,68 @@ object testGenericMethod1{
     val v = gm.identity[Int](42)
     println("identity[Int](42):" + v)
 
-  @main def main2(): Unit =
+  @main def main2(): Unit = 
+    val v = gm.identity2(2.2)
+    println("identity2(2.2):" + v)
+    
+  @main def main3(): Unit =
     val v = gm.first[Double, Long](4.2, 42L)
-    println("first[Double, Long](4.2, 42L)" + v)
-}
+    println("first[Double, Long](4.2, 42L):" + v)
 
-object testGenericMethod2{
-  val gm = new GenericMethod
-  @main def main(): Unit =
-    val v = gm.first[Double, Long](4.2, 42L)
-    println("first[Double, Long](4.2, 42L)" + v)
+  @main def main4(): Unit =
+    val v = gm.identity[Foo](new Foo(1))
+    println("identity[Foo](new Foo(1)):" + v)
+
+  @main def main5(): Unit =
+    val v = gm.passRef(new Foo(2))
+    println("passRef(new Foo(2)):" + v)
+
+  @main def main6(): Unit =
+    val v = gm.identity[java.lang.Integer](java.lang.Integer.valueOf(8))
+    println("identity[java.lang.Integer](java.lang.Integer.valueOf(8)):" + v)
+
+  @main def main7(): Unit =
+    val v = gm.identity2(java.lang.Integer.valueOf(87))
+    println("identity2(java.lang.Integer.valueOf(87)):" + v)
+
+  @main def main8(): Unit =
+    val v = gm.passInt(88)
+    println("passInt(88):" + v)
+
+  def genericMethod1[A, B, C](a: A, b: B, c: C): Unit =
+    val v1 = gm.identity[B](b)
+    println("identity[B](b):" + v1)
+    val v2 = gm.first[C, A](c, a)
+    println("first[C, A](c, a):" + v2)
+
+  @main def main9(): Unit =
+    genericMethod1[Int, Char, Double](1, 'a', 3.14)
+    // prints:
+    // identity[B](b): a
+    // first[C, A](c, a): 3.14
+  
+  @main def main10(): Unit =
+    genericMethod1[Foo, Foo, Foo](new Foo(1), new Foo(2), new Foo(3))
+    // prints:
+    // identity[B](b): Printing Foo 2
+    // first[C, A](c, a): Printing Foo 3
+
+  def genericMethod2[A, B, C](a: A, b: B, c: C): Unit =
+    val v1 = gm.identity2(c)
+    println("identity2(c):" + v1)
+
+  @main def main11(): Unit =
+    genericMethod2[Int, Char, Double](1, 'a', 3.14)
+    // prints:
+    // identity2(c): 3.14
+
+  @main def main12(): Unit =
+    genericMethod2[Foo, Foo, Foo](new Foo(1), new Foo(2), new Foo(3))
+    // prints:
+    // identity2(c): Printing Foo 3
 }
 
+/*
 object testGenericMethod {
   @main def testGenericMethodMain(): Unit = {
     println("test1:")
@@ -198,6 +247,7 @@ object testGenericMethod {
     val v8 : Any = v7
   }
 }
+*/
 
 class Foo(id: Int) {
   //arbitrary scala class