// This class is a complete ClassVisitor with many hidden classes that do
// the work of reading annotations from a class file and inserting them into
// an AScene.
package annotations.io.classfile;
/*>>>
import org.checkerframework.checker.nullness.qual.*;
*/
import java.io.File;
import java.util.*;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.TypeAnnotationVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.EmptyVisitor;
import annotations.*;
import annotations.el.*;
import annotations.field.*;
import com.sun.tools.javac.code.TargetType;
import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry;
/**
* A <code> ClassAnnotationSceneReader </code> is a
* {@link org.objectweb.asm.ClassVisitor} that will insert all annotations it
* encounters while visiting a class into a given {@link AScene}.
*
* The "read" in <code> ClassAnnotationSceneReader </code> refers to a class
* file being read into a scene. Also see {@link ClassAnnotationSceneWriter}.
*
* <p>
*
* The proper usage of this class is to construct a
* <code>ClassAnnotationSceneReader}</code> with an {@link AScene} into which
* annotations should be inserted, then pass this as a
* {@link org.objectweb.asm.ClassVisitor} to
* {@link org.objectweb.asm.ClassReader#accept}
*
* <p>
*
* All other methods are intended to be called only by
* {@link org.objectweb.asm.ClassReader#accept},
* and should not be called anywhere else, due to the order in which
* {@link org.objectweb.asm.ClassVisitor} methods should be called.
*/
public class ClassAnnotationSceneReader
extends EmptyVisitor {
// general strategy:
// -only "Runtime[In]visible[Type]Annotations" are supported
// -use an empty visitor for everything besides annotations, fields and
// methods; for those three, use a special visitor that does all the work
// and inserts the annotations correctly into the specified AElement
// Whether to output tracing information
private static final boolean trace = false;
// Whether to output error messages for unsupported cases
private static final boolean strict = false;
// Whether to include annotations on compiler-generated methods
private final boolean ignoreBridgeMethods;
// The scene into which this class will insert annotations.
private final AScene scene;
// The AClass that represents this class in scene.
private AClass aClass;
private final ClassReader cr;
/**
* Holds definitions we've seen so far. Maps from annotation name to
* the definition itself. Maps from both the qualified name and the
* unqualified name. If the unqualified name is not unique, it maps
* to null and the qualified name should be used instead. */
private final Map<String, AnnotationDef> adefs = initAdefs();
private static Map<String,AnnotationDef> initAdefs() {
Map<String,AnnotationDef> result = new HashMap<String,AnnotationDef>();
for (AnnotationDef ad : Annotations.standardDefs) {
result.put(ad.name, ad);
}
return result;
}
/**
* constructs a new <code> ClassAnnotationSceneReader </code> that will
* insert all the annotations in the class that it visits into
* <code> scene </code>
* @param cr
*
* @param scene the annotation scene into which annotations this visits
* will be inserted
* @param ignoreBridgeMethods whether to omit annotations on
* compiler-generated methods
*/
public ClassAnnotationSceneReader(ClassReader cr, AScene scene,
boolean ignoreBridgeMethods) {
this.cr = cr;
this.scene = scene;
this.ignoreBridgeMethods = ignoreBridgeMethods;
}
/**
* @see org.objectweb.asm.commons.EmptyVisitor#visit(int, int, java.lang.String, java.lang.String, java.lang.String, java.lang.String[])
*/
@Override
public void visit(int version, int access, String name, String signature,
String superName, String[] interfaces) {
aClass = scene.classes.vivify(name.replace('/', '.'));
}
/**
* @see org.objectweb.asm.commons.EmptyVisitor#visitAnnotation(java.lang.String, boolean)
*/
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
if (trace) { System.out.printf("visitAnnotation(%s, %s) in %s (%s)%n", desc, visible, this, this.getClass()); }
return visitTypeAnnotation(desc, visible, false);
}
/**
* @see org.objectweb.asm.commons.EmptyVisitor#visitTypeAnnotation(java.lang.String, boolean, boolean)
*/
@Override
public TypeAnnotationVisitor visitTypeAnnotation(String desc, boolean visible, boolean inCode) {
if (trace) { System.out.printf("visitTypeAnnotation(%s, %s, %s); aClass=%s in %s (%s)%n", desc, inCode, visible, aClass, this, this.getClass()); }
return new AnnotationSceneReader(desc, visible, aClass);
}
/**
* @see org.objectweb.asm.commons.EmptyVisitor#visitField(int, java.lang.String, java.lang.String, java.lang.String, java.lang.Object)
*/
@Override
public FieldVisitor visitField(
int access,
String name,
String desc,
String signature,
Object value ) {
if (trace) { System.out.printf("visitField(%s, %s, %s, %s, %s) in %s (%s)%n", access, name, desc, signature, value, this, this.getClass()); }
AField aField = aClass.fields.vivify(name);
return new FieldAnnotationSceneReader(name, desc, signature, value, aField);
}
/**
* @see org.objectweb.asm.commons.EmptyVisitor#visitMethod(int, java.lang.String, java.lang.String, java.lang.String, java.lang.String[])
*/
@Override
public MethodVisitor visitMethod(
int access,
String name,
String desc,
String signature,
String[] exceptions) {
if (ignoreBridgeMethods && (access & Opcodes.ACC_BRIDGE) != 0) {
return null;
}
if (trace) { System.out.printf("visitMethod(%s, %s, %s, %s, %s) in %s (%s)%n", access, name, desc, signature, exceptions, this, this.getClass()); }
AMethod aMethod = aClass.methods.vivify(name+desc);
return new MethodAnnotationSceneReader(name, desc, signature, aMethod);
}
// converts JVML format to Java format
private static String classDescToName(String desc) {
return desc.substring(1, desc.length() - 1).replace('/', '.');
}
///////////////////////////////////////////////////////////////////////////
/// Inner classes
///
// Hackish workaround for odd subclassing.
@SuppressWarnings("signature")
String dummyDesc = "dummy";
/*
* Most of the complexity behind reading annotations from a class file into
* a scene is in AnnotationSceneReader, which fully implements the
* TypeAnnotationVisitor interface (and therefore also implements the
* AnnotationVisitor interface). It keeps an AElement of the
* element into which this should insert the annotations it visits in
* a class file. Thus, constructing an AnnotationSceneReader with an
* AElement of the right type is sufficient for writing out annotations
* to that element, which will be done once visitEnd() is called. Note that
* for when inner annotations are expected, the aElement passed in must be
* of the correct form (ATypeElement, or AMethod depending on the
* target type of the extended annotation).
*/
private class AnnotationSceneReader implements TypeAnnotationVisitor {
// Implementation strategy:
// For field values and enums, simply pass the information
// onto annotationBuilder.
// For arrays, use an ArrayAnnotationBuilder that will
// properly call the right annotationBuilder methods on its visitEnd().
// For nested annotations, use a NestedAnnotationSceneReader that will
// properly call the right annotationBuilder methods on its visitEnd().
// For extended information, store all arguments passed in and on
// this.visitEnd(), handle all the information based on target type.
// The AElement into which the annotation visited should be inserted.
protected AElement aElement;
// Whether or not this annotation is visible at runtime.
protected boolean visible;
// The AnnotationBuilder used to create this annotation.
private AnnotationBuilder annotationBuilder;
// since AnnotationSceneReader will work for both normal
// and extended annotations, all of the following information
// may or may not be present, so use a list to store
// information as it is received from visitX* methods, and
// correctly interpret the information in visitEnd()
// note that all of these should contain 0 or 1 elements,
// except for xLocations, which is actually a list
private final List<Integer> xTargetTypeArgs;
private final List<Integer> xIndexArgs;
private final List<Integer> xLengthArgs;
private final List<TypePathEntry> xLocationsArgs;
private final List<Integer> xLocationLengthArgs;
private final List<Integer> xOffsetArgs;
private final List<Integer> xStartPcArgs;
private final List<Integer> xParamIndexArgs;
private final List<Integer> xBoundIndexArgs;
private final List<Integer> xExceptionIndexArgs;
private final List<Integer> xTypeIndexArgs;
// private AnnotationDef getAnnotationDef(Object o) {
// if (o instanceof AnnotationDef) {
// return (AnnotationDef) o;
// } else if (o instanceof String) {
// return getAnnotationDef((String) o);
// } else {
// throw new Error(String.format("bad type %s : %s", o.getClass(), o));
// }
// }
@SuppressWarnings("unchecked")
private AnnotationDef getAnnotationDef(String jvmlClassName) {
String annoTypeName = classDescToName(jvmlClassName);
// It would be better to not require the .class file to be on the
// classpath, but to search for it on a path that is passed to this
// program. Worry about that later.
Class<? extends java.lang.annotation.Annotation> annoClass;
try {
annoClass = (Class<? extends java.lang.annotation.Annotation>) Class.forName(annoTypeName);
} catch (ClassNotFoundException e) {
System.out.printf("Could not find class: %s%n", e.getMessage());
printClasspath();
if (annoTypeName.contains("+")) {
return Annotations.createValueAnnotationDef(annoTypeName,
Annotations.noAnnotations, BasicAFT.forType(int.class));
}
throw new Error(e);
}
AnnotationDef ad = AnnotationDef.fromClass(annoClass, adefs);
return ad;
}
/*
* Constructs a new AnnotationScene reader with the given description and
* visibility. Calling visitEnd() will ensure that this writes out the
* annotation it visits into aElement.
* @param desc JVML format for the field being read, or ClassAnnotationSceneReader.dummyDesc
*/
public AnnotationSceneReader(String desc, boolean visible, AElement aElement) {
if (trace) { System.out.printf("AnnotationSceneReader(%s, %s, %s)%n", desc, visible, aElement); }
this.visible = visible;
this.aElement = aElement;
if (desc != dummyDesc) { // interned
AnnotationDef ad = getAnnotationDef(desc);
AnnotationBuilder ab = AnnotationFactory.saf.beginAnnotation(ad);
if (ab == null) {
throw new IllegalArgumentException("bad description: " + desc);
} else {
this.annotationBuilder = ab;
}
}
// For legal annotations, and except for xLocationsArgs, these should
// contain at most one element.
this.xTargetTypeArgs = new ArrayList<Integer>(1);
this.xIndexArgs = new ArrayList<Integer>(1);
this.xLengthArgs = new ArrayList<Integer>(1);
this.xLocationLengthArgs = new ArrayList<Integer>(1);
this.xOffsetArgs = new ArrayList<Integer>(1);
this.xStartPcArgs = new ArrayList<Integer>(1);
this.xLocationsArgs = new ArrayList<TypePathEntry>();
this.xParamIndexArgs = new ArrayList<Integer>(1);
this.xBoundIndexArgs = new ArrayList<Integer>(1);
this.xExceptionIndexArgs = new ArrayList<Integer>(1);
this.xTypeIndexArgs = new ArrayList<Integer>(1);
}
/*
* @see org.objectweb.asm.AnnotationVisitor#visit(java.lang.String, java.lang.Object)
*/
@Override
public void visit(String name, Object value) {
if (trace) { System.out.printf("visit(%s, %s) on %s%n", name, value, this); }
// BasicAFT.forType(Class) expects int.class instead of Integer.class,
// and so on for all primitives. String.class is ok, since it has no
// primitive type.
Class<?> c = value.getClass();
if (c.equals(Boolean.class)) {
c = boolean.class;
} else if (c.equals(Byte.class)) {
c = byte.class;
} else if (c.equals(Character.class)) {
c = char.class;
} else if (c.equals(Short.class)) {
c = short.class;
} else if (c.equals(Integer.class)) {
c = int.class;
} else if (c.equals(Long.class)) {
c = long.class;
} else if (c.equals(Float.class)) {
c = float.class;
} else if (c.equals(Double.class)) {
c = double.class;
} else if (c.equals(Type.class)) {
try {
annotationBuilder.addScalarField(name, ClassTokenAFT.ctaft, Class.forName(((Type)value).getClassName()));
} catch (ClassNotFoundException e) {
throw new RuntimeException("Could not load Class for Type: " + value, e);
}
// Return here, otherwise the annotationBuilder would be called
// twice for the same value.
return;
} else if (!c.equals(String.class)) {
// Only possible type for value is String, in which case c is already
// String.class, or array of primitive
c = c.getComponentType();
ArrayBuilder arrayBuilder = annotationBuilder.beginArrayField(
name, new ArrayAFT(BasicAFT.forType(c)));
// value is of type c[], now add in all the elements of the array
for (Object o : asList(value)) {
arrayBuilder.appendElement(o);
}
arrayBuilder.finish();
return;
}
// handle everything but arrays
annotationBuilder.addScalarField(name, BasicAFT.forType(c),value);
}
/*
* Method that accepts an Object whose actual type is c[], where c is a
* primitive, and returns an equivalent List<Object> that contains
* the same elements as in hiddenArray.
*/
private List<Object> asList(Object hiddenArray) {
List<Object> objects = new ArrayList<Object>();
Class<?> c = hiddenArray.getClass().getComponentType();
if (c.equals(boolean.class)) {
for (boolean o : (boolean[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(byte.class)) {
for (byte o : (byte[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(char.class)) {
for (char o : (char[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(short.class)) {
for (short o : (short[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(int.class)) {
for (int o : (int[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(long.class)) {
for (long o : (long[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(float.class)) {
for (float o : (float[]) hiddenArray) {
objects.add(o);
}
} else if (c.equals(double.class)) {
for (double o : (double[]) hiddenArray) {
objects.add(o);
}
} else {
throw new RuntimeException("Array has unknown type: " + hiddenArray);
}
return objects;
}
/*
* @see org.objectweb.asm.AnnotationVisitor#visitEnum(java.lang.String, java.lang.String, java.lang.String)
*/
@Override
public void visitEnum(String name, String desc, String value) {
if (trace) { System.out.printf("visitEnum(%s, %s) in %s (%s)%n", name, desc, this, this.getClass()); }
annotationBuilder.addScalarField(name, new EnumAFT(desc), value);
}
/*
* @see org.objectweb.asm.AnnotationVisitor#visitAnnotation(java.lang.String, java.lang.String)
*/
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
if (trace) { System.out.printf("visitAnnotation(%s, %s) in %s (%s)%n", name, desc, this, this.getClass()); }
return new NestedAnnotationSceneReader(this, name, desc);
}
/*
* @see org.objectweb.asm.AnnotationVisitor#visitArray(java.lang.String)
*/
@Override
public AnnotationVisitor visitArray(String name) {
if (trace) { System.out.printf("visitArray(%s) in %s (%s)%n", name, this, this.getClass()); }
ArrayAFT aaft = (ArrayAFT) annotationBuilder.fieldTypes().get(name);
ScalarAFT aft = aaft.elementType;
return new ArrayAnnotationSceneReader(this, name, aft);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXTargetType(int)
*/
@Override
public void visitXTargetType(int target_type) {
xTargetTypeArgs.add(target_type);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXIndex(int)
*/
@Override
public void visitXIndex(int index) {
xIndexArgs.add(index);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXLength(int)
*/
@Override
public void visitXLength(int length) {
xLengthArgs.add(length);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXLocation(TypePathEntry)
*/
@Override
public void visitXLocation(TypePathEntry location) {
xLocationsArgs.add(location);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXLocationLength(int)
*/
@Override
public void visitXLocationLength(int location_length) {
xLocationLengthArgs.add(location_length);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXOffset(int)
*/
@Override
public void visitXOffset(int offset) {
xOffsetArgs.add(offset);
}
@Override
public void visitXNumEntries(int num_entries) {
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXStartPc(int)
*/
@Override
public void visitXStartPc(int start_pc) {
xStartPcArgs.add(start_pc);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXBoundIndex(int)
*/
@Override
public void visitXParamIndex(int param_index) {
xParamIndexArgs.add(param_index);
}
/*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitXBoundIndex(int)
*/
@Override
public void visitXBoundIndex(int bound_index) {
xBoundIndexArgs.add(bound_index);
}
@Override
public void visitXTypeIndex(int type_index) {
xTypeIndexArgs.add(type_index);
}
@Override
public void visitXExceptionIndex(int exception_index) {
xExceptionIndexArgs.add(exception_index);
}
@Override
public void visitXNameAndArgsSize() {
}
/*
* Visits the end of the annotation, and actually writes out the
* annotation into aElement.
*
* @see org.objectweb.asm.TypeAnnotationVisitor#visitEnd()
*/
@Override
public void visitEnd() {
if (trace) { System.out.printf("visitEnd on %s (%s)%n", this, this.getClass()); }
if (xTargetTypeArgs.size() >= 1) {
TargetType target = TargetType.fromTargetTypeValue(xTargetTypeArgs.get(0));
// TEMP
// If the expression used to initialize a field contains annotations
// on instanceofs, typecasts, or news, the extended compiler enters
// those annotations on the field. If we get such an annotation and
// aElement is a field, skip the annotation for now to avoid crashing.
switch(target) {
case FIELD:
handleField(aElement);
break;
case LOCAL_VARIABLE:
case RESOURCE_VARIABLE:
handleMethodLocalVariable((AMethod) aElement);
break;
case NEW:
if (aElement instanceof AMethod) {
handleMethodObjectCreation((AMethod) aElement);
} else {
// TODO: in field initializers
if (strict) { System.err.println("Unhandled NEW annotation for " + aElement); }
}
break;
case METHOD_FORMAL_PARAMETER:
handleMethodParameterType((AMethod) aElement);
break;
case METHOD_RECEIVER:
handleMethodReceiver((AMethod) aElement);
break;
case CAST:
if (aElement instanceof AMethod) {
handleMethodTypecast((AMethod) aElement);
} else {
// TODO: in field initializers
if (strict) { System.err.println("Unhandled TYPECAST annotation for " + aElement); }
}
break;
case METHOD_RETURN:
handleMethodReturnType((AMethod) aElement);
break;
case INSTANCEOF:
if (aElement instanceof AMethod) {
handleMethodInstanceOf((AMethod) aElement);
} else {
// TODO: in field initializers
if (strict) { System.err.println("Unhandled INSTANCEOF annotation for " + aElement); }
}
break;
case CLASS_TYPE_PARAMETER_BOUND:
handleClassTypeParameterBound((AClass) aElement);
break;
case METHOD_TYPE_PARAMETER_BOUND:
handleMethodTypeParameterBound((AMethod) aElement);
break;
case CLASS_EXTENDS:
handleClassExtends((AClass) aElement);
break;
case THROWS:
handleThrows((AMethod) aElement);
break;
case CONSTRUCTOR_REFERENCE: // TODO
case METHOD_REFERENCE:
handleMethodReference((AMethod) aElement);
break;
case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: // TODO
case METHOD_REFERENCE_TYPE_ARGUMENT:
handleReferenceTypeArgument((AMethod) aElement);
break;
case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: // TODO
case METHOD_INVOCATION_TYPE_ARGUMENT:
handleCallTypeArgument((AMethod) aElement);
break;
case METHOD_TYPE_PARAMETER:
handleMethodTypeParameter((AMethod) aElement);
break;
case CLASS_TYPE_PARAMETER:
handleClassTypeParameter((AClass) aElement);
break;
// TODO: ensure all cases covered.
default:
// Rather than throw an error here, since a declaration annotation
// is being used as an extended annotation, just make the
// annotation and place it in the given aElement as usual.
// aElement.tlAnnotationsHere.add(makeAnnotation());
Annotation a = makeAnnotation();
aElement.tlAnnotationsHere.add(a);
}
} else {
// This is not an extended annotation visitor, so just
// make the annotation and place it in the given AElement,
// possibly moving it to a type annotation location instead.
Annotation a = makeAnnotation();
if (a.def.isTypeAnnotation() && (aElement instanceof AMethod)) {
AMethod m = (AMethod) aElement;
m.returnType.tlAnnotationsHere.add(a);
// There is not currently a separate location for field/parameter
// type annotations; they are mixed in with the declaration
// annotations. This should be fixed in the future.
// Also, fields/parameters are just represented as AElement.
// } else if (a.def.isTypeAnnotation() && (aElement instanceof AField)) {
} else {
aElement.tlAnnotationsHere.add(a);
}
}
}
// The following are utility methods to facilitate creating all the
// necessary data structures in the scene library.
/*
* Returns an annotation, ready to be placed into the scene, from
* the information visited.
*/
public Annotation makeAnnotation() {
return annotationBuilder.finish();
}
/*
* Returns a LocalLocation for this annotation.
*/
private LocalLocation makeLocalLocation() {
int index = xIndexArgs.get(0);
int length = xLengthArgs.get(0);
int start = xStartPcArgs.get(0);
return new LocalLocation(index, start, length);
}
/*
* Returns an InnerTypeLocation for this annotation.
*/
private InnerTypeLocation makeInnerTypeLocation() {
return new InnerTypeLocation(xLocationsArgs);
}
/*
* Returns the offset for this annotation.
*/
private RelativeLocation makeOffset(boolean needTypeIndex) {
int offset = xOffsetArgs.get(0);
int typeIndex = needTypeIndex ? xTypeIndexArgs.get(0) : 0;
return RelativeLocation.createOffset(offset, typeIndex);
}
/*
* Returns the index for this annotation.
*/
/*
private int makeIndex() {
return xIndexArgs.get(0);
}
*/
/*
* Returns the bound location for this annotation.
*/
private BoundLocation makeTypeParameterLocation() {
if (!xParamIndexArgs.isEmpty()) {
return new BoundLocation(xParamIndexArgs.get(0), -1);
} else {
if (strict) { System.err.println("makeTypeParameterLocation with empty xParamIndexArgs!"); }
return new BoundLocation(Integer.MAX_VALUE, -1);
}
}
/*
* Returns the bound location for this annotation.
* @see #makeTypeParameterLocation()
*/
private BoundLocation makeBoundLocation() {
// TODO: Give up on unbounded wildcards for now!
if (!xParamIndexArgs.isEmpty()) {
return new BoundLocation(xParamIndexArgs.get(0), xBoundIndexArgs.get(0));
} else {
if (strict) { System.err.println("makeBoundLocation with empty xParamIndexArgs!"); }
return new BoundLocation(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
}
private TypeIndexLocation makeTypeIndexLocation() {
return new TypeIndexLocation(xTypeIndexArgs.get(0));
}
// TODO: makeExceptionIndexLocation?
/*
* Creates the inner annotation on aElement.innerTypes.
*/
private void handleField(AElement aElement) {
if (xLocationsArgs.isEmpty()) {
// TODO: resolve issue once classfile format is finalized
if (aElement instanceof AClass) {
// handleFieldOnClass((AClass) aElement);
if (strict) { System.err.println("Unhandled FIELD annotation for " + aElement); }
} else if (aElement instanceof ATypeElement) {
aElement.tlAnnotationsHere.add(makeAnnotation());
} else {
throw new RuntimeException("Unknown FIELD aElement: " + aElement);
}
} else {
// TODO: resolve issue once classfile format is finalized
if (aElement instanceof AClass) {
// handleFieldGenericArrayOnClass((AClass) aElement);
if (strict) { System.err.println("Unhandled FIELD_COMPONENT annotation for " + aElement); }
} else if (aElement instanceof ATypeElement) {
ATypeElement aTypeElement = (ATypeElement) aElement;
aTypeElement
.innerTypes.vivify(makeInnerTypeLocation()).
tlAnnotationsHere.add(makeAnnotation());
} else {
throw new RuntimeException("Unknown FIELD_COMPONENT: " + aElement);
}
}
}
/*
* Creates the method receiver annotation on aMethod.
*/
private void handleMethodReceiver(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.receiver.type
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.receiver.type
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the local variable annotation on aMethod.
*/
private void handleMethodLocalVariable(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.locals.vivify(makeLocalLocation())
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.locals.vivify(makeLocalLocation())
.type.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the object creation annotation on aMethod.
*/
private void handleMethodObjectCreation(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.news.vivify(makeOffset(false))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.news.vivify(makeOffset(false))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private int makeParamIndex() {
return xParamIndexArgs.get(0);
}
/*
* Creates the method parameter type generic/array annotation on aMethod.
*/
private void handleMethodParameterType(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.parameters.vivify(makeParamIndex()).type.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.parameters.vivify(makeParamIndex()).type.innerTypes.vivify(
makeInnerTypeLocation()).tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the typecast annotation on aMethod.
*/
private void handleMethodTypecast(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.typecasts.vivify(makeOffset(true))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.typecasts.vivify(makeOffset(true))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the method return type generic/array annotation on aMethod.
*/
private void handleMethodReturnType(AMethod aMethod) {
// TODO: why is this traced and not other stuff?
if (trace) { System.out.printf("handleMethodReturnType(%s)%n", aMethod); }
if (xLocationsArgs.isEmpty()) {
aMethod.returnType
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.returnType
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the method instance of annotation on aMethod.
*/
private void handleMethodInstanceOf(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.instanceofs.vivify(makeOffset(false))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.typecasts.vivify(makeOffset(false))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the class type parameter bound annotation on aClass.
*/
private void handleClassTypeParameter(AClass aClass) {
aClass.bounds.vivify(makeTypeParameterLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
/*
* Creates the class type parameter bound annotation on aClass.
*/
private void handleClassTypeParameterBound(AClass aClass) {
if (xLocationsArgs.isEmpty()) {
aClass.bounds.vivify(makeBoundLocation())
.tlAnnotationsHere.add(makeAnnotation());
} else {
aClass.bounds.vivify(makeBoundLocation())
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
/*
* Creates the class type parameter bound annotation on aClass.
*/
private void handleMethodTypeParameterBound(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.bounds.vivify(makeBoundLocation())
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.bounds.vivify(makeBoundLocation())
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private void handleClassExtends(AClass aClass) {
if (xLocationsArgs.isEmpty()) {
aClass.extendsImplements.vivify(makeTypeIndexLocation())
.tlAnnotationsHere.add(makeAnnotation());
} else {
aClass.extendsImplements.vivify(makeTypeIndexLocation())
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private void handleThrows(AMethod aMethod) {
aMethod.throwsException.vivify(makeTypeIndexLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
private void handleNewTypeArgument(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
// aMethod.news.vivify(makeOffset()).innerTypes.vivify();
// makeInnerTypeLocation()).tlAnnotationsHere.add(makeAnnotation());
if (strict) { System.err.println("Unhandled handleNewTypeArgument on aMethod: " + aMethod); }
} else {
// if (strict) { System.err.println("Unhandled handleNewTypeArgumentGenericArray on aMethod: " + aMethod); }
}
}
private void handleMethodReference(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.refs.vivify(makeOffset(false))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.refs.vivify(makeOffset(false))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private void handleReferenceTypeArgument(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.refs.vivify(makeOffset(true))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.refs.vivify(makeOffset(true))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private void handleCallTypeArgument(AMethod aMethod) {
if (xLocationsArgs.isEmpty()) {
aMethod.body.calls.vivify(makeOffset(true))
.tlAnnotationsHere.add(makeAnnotation());
} else {
aMethod.body.calls.vivify(makeOffset(true))
.innerTypes.vivify(makeInnerTypeLocation())
.tlAnnotationsHere.add(makeAnnotation());
}
}
private void handleMethodTypeParameter(AMethod aMethod) {
// TODO: throw new RuntimeException("METHOD_TYPE_PARAMETER: to do");
}
/*
* Hook for NestedAnnotationSceneReader; overridden by
* ArrayAnnotationSceneReader to add an array element instead of a field
*/
void supplySubannotation(String fieldName, Annotation annotation) {
annotationBuilder.addScalarField(fieldName,
new AnnotationAFT(annotation.def()), annotation);
}
@Override
public String toString() {
return String.format("(AnnotationSceneReader: %s %s %s)",
aElement, visible, annotationBuilder);
}
}
/*
* A NestedAnnotationSceneReader is an AnnotationSceneReader
* that will read in an entire annotation on a field (of type annotation)
* of its parent, and once it has fully visited that annotation, it will
* call its parent annotation builder to include that field, so after
* its parent constructs and returns this as an AnnotationVisitor
* (visitAnnotation()), it no longer needs to worry about that field.
*/
private class NestedAnnotationSceneReader extends AnnotationSceneReader {
private final AnnotationSceneReader parent;
private final String name;
// private final String desc;
public NestedAnnotationSceneReader(AnnotationSceneReader parent,
String name, String desc) {
super(desc, parent.visible, parent.aElement);
if (trace) { System.out.printf("NestedAnnotationSceneReader(%s, %s, %s)%n", parent, name, desc); }
this.parent = parent;
this.name = name;
// this.desc = desc;
}
@Override
public void visitEnd() {
// Do not call super, as that already builds the annotation, causing an exception.
// super.visitEnd();
if (trace) { System.out.printf("visitEnd on %s (%s)%n", this, this.getClass()); }
Annotation a = super.makeAnnotation();
parent.supplySubannotation(name, a);
}
}
/*
* An ArrayAnnotationSceneReader is an AnnotationSceneReader
* that reads all elements of an array field
* of its parent, and once it has fully visited the array, it will
* call its parent annotation builder to include that array, so after
* its parent constructs and returns this as an AnnotationVisitor
* (visitArray()), it no longer needs to worry about that array.
*
* Note that by specification of AnnotationVisitor.visitArray(), the only
* methods that should be called on this are visit(String name, Object value)
* and visitEnd().
*/
// An AnnotationSceneReader reads an annotation. An
// ArrayAnnotationSceneReader reads an arbitrary array field, but not an
// entire annotation. So why is ArrayAnnotationSceneReader a subclass of
// AnnotationSceneReader? Pass ClassAnnotationSceneReader.dummyDesc
// in the superclass constructor to
// disable superclass behaviors that would otherwise cause trouble.
private class ArrayAnnotationSceneReader extends AnnotationSceneReader {
private final AnnotationSceneReader parent;
private ArrayBuilder arrayBuilder;
// private ScalarAFT elementType;
private final String arrayName;
// The element type may be unknown when this is called.
// But AnnotationSceneReader expects to know the element type.
public ArrayAnnotationSceneReader(AnnotationSceneReader parent,
String fieldName, AnnotationFieldType eltType) {
super(dummyDesc, parent.visible, parent.aElement);
if (trace) { System.out.printf("ArrayAnnotationSceneReader(%s, %s)%n", parent, fieldName); }
this.parent = parent;
this.arrayName = fieldName;
this.arrayBuilder = null;
}
private void prepareForElement(ScalarAFT elementType) {
if (trace) { System.out.printf("prepareForElement(%s) in %s (%s)%n", elementType, this, this.getClass()); }
assert elementType != null; // but, does this happen when reading from classfile?
if (arrayBuilder == null) {
// this.elementType = elementType;
arrayBuilder = parent.annotationBuilder.beginArrayField(arrayName,
new ArrayAFT(elementType));
}
}
// There are only so many different array types that are permitted in
// an annotation. (I'm not sure how relevant that is here.)
@Override
public void visit(String name, Object value) {
if (trace) { System.out.printf("visit(%s, %s) (%s) in %s (%s)%n", name, value, value.getClass(), this, this.getClass()); }
ScalarAFT aft;
if (value.getClass().equals(org.objectweb.asm.Type.class)) {
// What if it's an annotation?
aft = ClassTokenAFT.ctaft;
try {
value = Class.forName(((org.objectweb.asm.Type) value).getClassName());
} catch (ClassNotFoundException e) {
throw new RuntimeException("Could not load Class for Type: " + value, e);
}
} else {
Class<?> vc = value.getClass();
aft = BasicAFT.forType(vc);
// or: aft = (ScalarAFT) AnnotationFieldType.fromClass(vc, null);
}
assert aft != null;
prepareForElement(aft);
assert arrayBuilder != null;
arrayBuilder.appendElement(value);
}
@Override
public void visitEnum(String name, String desc, String value) {
if (trace) { System.out.printf("visitEnum(%s, %s, %s) in %s (%s)%n", name, desc, value, this, this.getClass()); }
prepareForElement(new EnumAFT(classDescToName(desc)));
assert arrayBuilder != null;
arrayBuilder.appendElement(value);
}
@Override
public AnnotationVisitor visitArray(String name) {
throw new AssertionError("Multidimensional array in annotation!");
}
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
if (trace) { System.out.printf("visitAnnotation(%s, %s) in %s (%s)%n", name, desc, this, this.getClass()); }
// The NASR will regurgitate the name we pass here when it calls
// supplySubannotation. Since we ignore the name there, it doesn't
// matter what name we pass here.
return new NestedAnnotationSceneReader(this, name, desc);
}
@Override
public void visitEnd() {
if (trace) { System.out.printf("visitEnd on %s (%s)%n", this, this.getClass()); }
if (arrayBuilder != null) {
arrayBuilder.finish();
} else {
// This was a zero-element array
parent.annotationBuilder.addEmptyArrayField(arrayName);
}
}
@Override
void supplySubannotation(String fieldName, Annotation annotation) {
prepareForElement(new AnnotationAFT(annotation.def()));
assert arrayBuilder != null;
arrayBuilder.appendElement(annotation);
}
}
/*
* A FieldAnnotationSceneReader is a FieldVisitor that only cares about
* visiting [extended]annotations. Attributes are ignored and visitEnd() has
* no effect. An AnnotationSceneReader is returned for declaration and type
* AnnotationVisitors. The AnnotationSceneReaders have a reference to
* an ATypeElement that this is visiting, and they will write out
* all the information to that ATypeElement after visiting each annotation.
*/
private class FieldAnnotationSceneReader extends EmptyVisitor implements FieldVisitor {
/*
private final String name;
private final String desc;
private final String signature;
private final Object value;
*/
private final AElement aField;
public FieldAnnotationSceneReader(
String name,
String desc,
String signature,
Object value,
AElement aField) {
/*
this.name = name;
this.desc = desc;
this.signature = signature;
this.value = value;
*/
this.aField = aField;
}
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
if (trace) { System.out.printf("visitAnnotation(%s, %s) in %s (%s)%n", desc, visible, this, this.getClass()); }
return new AnnotationSceneReader(desc, visible, aField);
}
@Override
public TypeAnnotationVisitor visitTypeAnnotation(String desc, boolean visible, boolean inCode) {
if (trace) { System.out.printf("visitTypeAnnotation(%s, %s, %s); aField=%s, aField.type=%s in %s (%s)%n", desc, visible, inCode, aField, aField.type, this, this.getClass()); }
return new AnnotationSceneReader(desc, visible, aField.type);
}
}
/*
* Similarly to FieldAnnotationSceneReader, this is a MethodVisitor that
* only cares about visiting [extended]annotations. Attributes other than
* BootstrapMethods are ignored, all code is ignored, and visitEnd() has no
* effect. An AnnotationSceneReader
* is returned for declaration and type AnnotationVisitors. The
* AnnotationSceneReaders have a reference to an AMethod that this is
* visiting, and they will write out all the information to that
* AMethod after visiting each annotation.
*/
private class MethodAnnotationSceneReader extends EmptyVisitor implements MethodVisitor {
// private final String name;
// private final String desc;
// private final String signature;
private final AElement aMethod;
public MethodAnnotationSceneReader(String name, String desc, String signature, AElement aMethod) {
// this.name = name;
// this.desc = desc;
// this.signature = signature;
this.aMethod = aMethod;
}
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
if (trace) { System.out.printf("visitAnnotation(%s, %s) in %s (%s)%n", desc, visible, this, this.getClass()); }
return visitTypeAnnotation(desc, visible, false);
}
@Override
public TypeAnnotationVisitor visitTypeAnnotation(String desc, boolean visible, boolean inCode) {
if (trace) { System.out.printf("visitTypeAnnotation(%s, %s) method=%s in %s (%s)%n", desc, visible, inCode, aMethod, this, this.getClass()); }
return new AnnotationSceneReader(desc, visible, aMethod);
}
@Override
public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) {
if (trace) { System.out.printf("visitParameterAnnotation(%s, %s, %s) in %s (%s)%n", parameter, desc, visible, this, this.getClass()); }
return new AnnotationSceneReader(desc, visible,
((AMethod) aMethod).parameters.vivify(parameter));
}
@Override
public void visitLocalVariable(String name, String desc, String signature,
Label start, Label end, int index) {
// TODO!
}
// TODO: visit code!
}
public static void printClasspath() {
System.out.println("\nClasspath:");
StringTokenizer tokenizer =
new StringTokenizer(System.getProperty("java.class.path"),
File.pathSeparator);
while (tokenizer.hasMoreTokens()) {
System.out.println(" " + tokenizer.nextToken());
}
}
}