6855990: javap InstructionDetailWriter should support new 308 annotations attribute

Reviewed-by: mcimadamore

src/share/classes/com/sun/tools/classfile/ExtendedAnnotation.java

@@ -260,9 +260,6 @@ public class ExtendedAnnotation {
         // For generic/array types.
         public List<Integer> location = new ArrayList<Integer>();
 
-        // Tree position.
-        public int pos = -1;
-
         // For typecasts, type tests, new (and locals, as start_pc).
         public int offset = -1;
 
@@ -391,9 +388,6 @@ public class ExtendedAnnotation {
                 sb.append(")");
             }
 
-            sb.append(", pos = ");
-            sb.append(pos);
-
             sb.append(']');
             return sb.toString();
         }

src/share/classes/com/sun/tools/javap/AnnotationWriter.java

@@ -32,6 +32,10 @@ import com.sun.tools.classfile.Annotation.Array_element_value;
 import com.sun.tools.classfile.Annotation.Class_element_value;
 import com.sun.tools.classfile.Annotation.Enum_element_value;
 import com.sun.tools.classfile.Annotation.Primitive_element_value;
+import com.sun.tools.classfile.ConstantPool;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.classfile.Descriptor;
+import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
 
 /**
  *  A writer for writing annotations as text.
@@ -51,71 +55,243 @@ public class AnnotationWriter extends BasicWriter {
 
     protected AnnotationWriter(Context context) {
         super(context);
+        classWriter = ClassWriter.instance(context);
+        constantWriter = ConstantWriter.instance(context);
     }
 
     public void write(Annotation annot) {
-        print("#" + annot.type_index + "(");
+        write(annot, false);
+    }
+
+    public void write(Annotation annot, boolean resolveIndices) {
+        writeDescriptor(annot.type_index, resolveIndices);
+        boolean showParens = annot.num_element_value_pairs > 0 || !resolveIndices;
+        if (showParens)
+            print("(");
         for (int i = 0; i < annot.num_element_value_pairs; i++) {
             if (i > 0)
                 print(",");
-            write(annot.element_value_pairs[i]);
+            write(annot.element_value_pairs[i], resolveIndices);
         }
-        print(")");
+        if (showParens)
+            print(")");
     }
 
     public void write(ExtendedAnnotation annot) {
-        write(annot.annotation);
-        print('@');
-        print(annot.position.toString());
+        write(annot, true, false);
+    }
+
+    public void write(ExtendedAnnotation annot, boolean showOffsets, boolean resolveIndices) {
+        write(annot.annotation, resolveIndices);
+        print(": ");
+        write(annot.position, showOffsets);
+    }
+
+    public void write(ExtendedAnnotation.Position pos, boolean showOffsets) {
+        print(pos.type);
+
+        switch (pos.type) {
+        // type case
+        case TYPECAST:
+        case TYPECAST_GENERIC_OR_ARRAY:
+        // object creation
+        case INSTANCEOF:
+        case INSTANCEOF_GENERIC_OR_ARRAY:
+        // new expression
+        case NEW:
+        case NEW_GENERIC_OR_ARRAY:
+        case NEW_TYPE_ARGUMENT:
+        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
+            if (showOffsets) {
+                print(", offset=");
+                print(pos.offset);
+            }
+            break;
+         // local variable
+        case LOCAL_VARIABLE:
+        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
+            print(", {");
+            for (int i = 0; i < pos.lvarOffset.length; ++i) {
+                if (i != 0) print("; ");
+                if (showOffsets) {
+                    print(", start_pc=");
+                    print(pos.lvarOffset[i]);
+                }
+                print(", length=");
+                print(pos.lvarLength[i]);
+                print(", index=");
+                print(pos.lvarIndex[i]);
+            }
+            print("}");
+            break;
+         // method receiver
+        case METHOD_RECEIVER:
+            // Do nothing
+            break;
+        // type parameters
+        case CLASS_TYPE_PARAMETER:
+        case METHOD_TYPE_PARAMETER:
+            print(", param_index=");
+            print(pos.parameter_index);
+            break;
+        // type parameters bound
+        case CLASS_TYPE_PARAMETER_BOUND:
+        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
+        case METHOD_TYPE_PARAMETER_BOUND:
+        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
+            print(", param_index=");
+            print(pos.parameter_index);
+            print(", bound_index=");
+            print(pos.bound_index);
+            break;
+         // wildcard
+        case WILDCARD_BOUND:
+        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
+            print(", wild_card=");
+            print(pos.wildcard_position);
+            break;
+         // Class extends and implements clauses
+        case CLASS_EXTENDS:
+        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
+            print(", type_index=");
+            print(pos.type_index);
+            break;
+        // throws
+        case THROWS:
+            print(", type_index=");
+            print(pos.type_index);
+            break;
+        case CLASS_LITERAL:
+            if (showOffsets) {
+                print(", offset=");
+                print(pos.offset);
+            }
+            break;
+        // method parameter: not specified
+        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
+            print(", param_index=");
+            print(pos.parameter_index);
+            break;
+        // method type argument: wasn't specified
+        case METHOD_TYPE_ARGUMENT:
+        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
+            if (showOffsets) {
+                print(", offset=");
+                print(pos.offset);
+            }
+            print(", type_index=");
+            print(pos.type_index);
+            break;
+        // We don't need to worry abut these
+        case METHOD_RETURN_GENERIC_OR_ARRAY:
+        case FIELD_GENERIC_OR_ARRAY:
+            break;
+        case UNKNOWN:
+            break;
+        default:
+            throw new AssertionError("unknown type: " + pos.type);
+        }
+
+        // Append location data for generics/arrays.
+        if (pos.type.hasLocation()) {
+            print(", location=");
+            print(pos.location);
+        }
     }
 
     public void write(Annotation.element_value_pair pair) {
-        print("#" + pair.element_name_index + ":");
-        write(pair.value);
+        write(pair, false);
+    }
+
+    public void write(Annotation.element_value_pair pair, boolean resolveIndices) {
+        writeIndex(pair.element_name_index, resolveIndices);
+        print("=");
+        write(pair.value, resolveIndices);
     }
 
     public void write(Annotation.element_value value) {
-        ev_writer.write(value);
+        write(value, false);
+    }
+
+    public void write(Annotation.element_value value, boolean resolveIndices) {
+        ev_writer.write(value, resolveIndices);
+    }
+
+    private void writeDescriptor(int index, boolean resolveIndices) {
+        if (resolveIndices) {
+            try {
+                ConstantPool constant_pool = classWriter.getClassFile().constant_pool;
+                Descriptor d = new Descriptor(index);
+                print(d.getFieldType(constant_pool));
+                return;
+            } catch (ConstantPoolException ignore) {
+            } catch (InvalidDescriptor ignore) {
+            }
+        }
+
+        print("#" + index);
+    }
+
+    private void writeIndex(int index, boolean resolveIndices) {
+        if (resolveIndices) {
+            print(constantWriter.stringValue(index));
+        } else
+            print("#" + index);
     }
 
     element_value_Writer ev_writer = new element_value_Writer();
 
-    class element_value_Writer implements Annotation.element_value.Visitor<Void,Void> {
-        public void write(Annotation.element_value value) {
-            value.accept(this, null);
+    class element_value_Writer implements Annotation.element_value.Visitor<Void,Boolean> {
+        public void write(Annotation.element_value value, boolean resolveIndices) {
+            value.accept(this, resolveIndices);
         }
 
-        public Void visitPrimitive(Primitive_element_value ev, Void p) {
-            print(((char) ev.tag) + "#" + ev.const_value_index);
+        public Void visitPrimitive(Primitive_element_value ev, Boolean resolveIndices) {
+            if (resolveIndices)
+                writeIndex(ev.const_value_index, resolveIndices);
+            else
+                print(((char) ev.tag) + "#" + ev.const_value_index);
             return null;
         }
 
-        public Void visitEnum(Enum_element_value ev, Void p) {
-            print(((char) ev.tag) + "#" + ev.type_name_index + ".#" + ev.const_name_index);
+        public Void visitEnum(Enum_element_value ev, Boolean resolveIndices) {
+            if (resolveIndices) {
+                writeIndex(ev.type_name_index, resolveIndices);
+                print(".");
+                writeIndex(ev.const_name_index, resolveIndices);
+            } else
+                print(((char) ev.tag) + "#" + ev.type_name_index + ".#" + ev.const_name_index);
             return null;
         }
 
-        public Void visitClass(Class_element_value ev, Void p) {
-            print(((char) ev.tag) + "#" + ev.class_info_index);
+        public Void visitClass(Class_element_value ev, Boolean resolveIndices) {
+            if (resolveIndices) {
+                writeIndex(ev.class_info_index, resolveIndices);
+                print(".class");
+            } else
+                print(((char) ev.tag) + "#" + ev.class_info_index);
             return null;
         }
 
-        public Void visitAnnotation(Annotation_element_value ev, Void p) {
+        public Void visitAnnotation(Annotation_element_value ev, Boolean resolveIndices) {
             print((char) ev.tag);
-            AnnotationWriter.this.write(ev.annotation_value);
+            AnnotationWriter.this.write(ev.annotation_value, resolveIndices);
             return null;
         }
 
-        public Void visitArray(Array_element_value ev, Void p) {
+        public Void visitArray(Array_element_value ev, Boolean resolveIndices) {
             print("[");
             for (int i = 0; i < ev.num_values; i++) {
                 if (i > 0)
                     print(",");
-                write(ev.values[i]);
+                write(ev.values[i], resolveIndices);
             }
             print("]");
             return null;
         }
 
     }
+
+    private ClassWriter classWriter;
+    private ConstantWriter constantWriter;
 }

src/share/classes/com/sun/tools/javap/CodeWriter.java

@@ -64,6 +64,7 @@ class CodeWriter extends BasicWriter {
         stackMapWriter = StackMapWriter.instance(context);
         localVariableTableWriter = LocalVariableTableWriter.instance(context);
         localVariableTypeTableWriter = LocalVariableTypeTableWriter.instance(context);
+        typeAnnotationWriter = TypeAnnotationWriter.instance(context);
         options = Options.instance(context);
     }
 
@@ -253,6 +254,11 @@ class CodeWriter extends BasicWriter {
             detailWriters.add(tryBlockWriter);
         }
 
+        if (options.details.contains(InstructionDetailWriter.Kind.TYPE_ANNOS)) {
+            typeAnnotationWriter.reset(attr);
+            detailWriters.add(typeAnnotationWriter);
+        }
+
         return detailWriters;
     }
 
@@ -261,6 +267,7 @@ class CodeWriter extends BasicWriter {
     private ConstantWriter constantWriter;
     private LocalVariableTableWriter localVariableTableWriter;
     private LocalVariableTypeTableWriter localVariableTypeTableWriter;
+    private TypeAnnotationWriter typeAnnotationWriter;
     private SourceWriter sourceWriter;
     private StackMapWriter stackMapWriter;
     private TryBlockWriter tryBlockWriter;

src/share/classes/com/sun/tools/javap/InstructionDetailWriter.java

@@ -42,7 +42,8 @@ public abstract class InstructionDetailWriter extends BasicWriter {
         LOCAL_VAR_TYPES("localVariableTypes"),
         SOURCE("source"),
         STACKMAPS("stackMaps"),
-        TRY_BLOCKS("tryBlocks");
+        TRY_BLOCKS("tryBlocks"),
+        TYPE_ANNOS("typeAnnotations");
         Kind(String option) {
             this.option = option;
         }

src/share/classes/com/sun/tools/javap/TypeAnnotationWriter.java

+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+package com.sun.tools.javap;
+
+import com.sun.tools.classfile.Attribute;
+import com.sun.tools.classfile.Code_attribute;
+import com.sun.tools.classfile.ExtendedAnnotation;
+import com.sun.tools.classfile.ExtendedAnnotation.Position;
+import com.sun.tools.classfile.Instruction;
+import com.sun.tools.classfile.Method;
+import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
+import com.sun.tools.classfile.RuntimeTypeAnnotations_attribute;
+import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Annotate instructions with details about type annotations.
+ *
+ *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
+ *  you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+public class TypeAnnotationWriter extends InstructionDetailWriter {
+    public enum NoteKind { VISIBLE, INVISIBLE };
+    public static class Note {
+        Note(NoteKind kind, ExtendedAnnotation anno) {
+            this.kind = kind;
+            this.anno = anno;
+        }
+        public final NoteKind kind;
+        public final ExtendedAnnotation anno;
+    }
+
+    static TypeAnnotationWriter instance(Context context) {
+        TypeAnnotationWriter instance = context.get(TypeAnnotationWriter.class);
+        if (instance == null)
+            instance = new TypeAnnotationWriter(context);
+        return instance;
+    }
+
+    protected TypeAnnotationWriter(Context context) {
+        super(context);
+        context.put(TypeAnnotationWriter.class, this);
+        annotationWriter = AnnotationWriter.instance(context);
+        classWriter = ClassWriter.instance(context);
+    }
+
+    public void reset(Code_attribute attr) {
+        Method m = classWriter.getMethod();
+        pcMap = new HashMap<Integer, List<Note>>();
+        check(NoteKind.VISIBLE, (RuntimeVisibleTypeAnnotations_attribute) m.attributes.get(Attribute.RuntimeVisibleTypeAnnotations));
+        check(NoteKind.INVISIBLE, (RuntimeInvisibleTypeAnnotations_attribute) m.attributes.get(Attribute.RuntimeInvisibleTypeAnnotations));
+    }
+
+    private void check(NoteKind kind, RuntimeTypeAnnotations_attribute attr) {
+        if (attr == null)
+            return;
+
+        for (ExtendedAnnotation anno: attr.annotations) {
+            Position p = anno.position;
+            Note note = null;
+            if (p.offset != -1)
+                addNote(p.offset, note = new Note(kind, anno));
+            if (p.lvarOffset != null) {
+                for (int i = 0; i < p.lvarOffset.length; i++) {
+                    if (note == null)
+                        note = new Note(kind, anno);
+                    addNote(p.lvarOffset[i], note);
+                }
+            }
+        }
+    }
+
+    private void addNote(int pc, Note note) {
+        List<Note> list = pcMap.get(pc);
+        if (list == null)
+            pcMap.put(pc, list = new ArrayList<Note>());
+        list.add(note);
+    }
+
+    @Override
+    void writeDetails(Instruction instr) {
+        String indent = space(2); // get from Options?
+        int pc = instr.getPC();
+        List<Note> notes = pcMap.get(pc);
+        if (notes != null) {
+            for (Note n: notes) {
+                print(indent);
+                print("@");
+                annotationWriter.write(n.anno, false, true);
+                print(", ");
+                println(n.kind.toString().toLowerCase());
+            }
+        }
+    }
+
+    private AnnotationWriter annotationWriter;
+    private ClassWriter classWriter;
+    private Map<Integer, List<Note>> pcMap;
+}

test/tools/javap/typeAnnotations/T6855990.java

+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+import java.io.*;
+
+/*
+ * @test
+ * @bug 6855990
+ * @summary InstructionDetailWriter should support new 308 annotations attribute
+ */
+
+public class T6855990 {
+    public static void main(String[] args) throws Exception {
+        new T6855990().run();
+    }
+
+    public void run() throws Exception {
+        @Simple String[] args = { "-c", "-XDdetails:typeAnnotations", "T6855990" };
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        int rc = com.sun.tools.javap.Main.run(args, pw);
+        pw.close();
+        String out = sw.toString();
+        System.out.println(out);
+        if (out.indexOf("@Simple: LOCAL_VARIABLE") == -1)
+            throw new Exception("expected output not found");
+    }
+}
+
+@interface Simple { }
+