javacutil.src.org.checkerframework.javacutil.TypeAnnotationUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of checker Show documentation
Show all versions of checker Show documentation
The Checker Framework enhances Java’s type system to
make it more powerful and useful. This lets software developers
detect and prevent errors in their Java programs.
The Checker Framework includes compiler plug-ins ("checkers")
that find bugs or verify their absence. It also permits you to
write your own compiler plug-ins.
package org.checkerframework.javacutil;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Map;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.AnnotationValueVisitor;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import com.sun.tools.javac.code.Attribute;
import com.sun.tools.javac.code.Attribute.TypeCompound;
import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.TargetType;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.TypeAnnotationPosition;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree.JCLambda;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Pair;
/**
* A collection of helper methods related to type annotation handling.
*
* @see AnnotationUtils
*/
public class TypeAnnotationUtils {
// Class cannot be instantiated.
private TypeAnnotationUtils() { throw new AssertionError("Class TypeAnnotationUtils cannot be instantiated."); }
/**
* Check whether a TypeCompound is contained in a list of TypeCompounds.
*
* @param list the input list of TypeCompounds
* @param tc the TypeCompound to find
* @return true, iff a TypeCompound equal to tc is contained in list
*/
public static boolean isTypeCompoundContained(Types types, List list, TypeCompound tc) {
for (Attribute.TypeCompound rawat : list) {
if (contentEquals(rawat.type.tsym.name, tc.type.tsym.name) &&
// TODO: in previous line, it would be nicer to use reference equality:
// rawat.type == tc.type &&
// or at least "isSameType":
// types.isSameType(rawat.type, tc.type) &&
// but each fails in some cases.
rawat.values.equals(tc.values) &&
isSameTAPositionExceptTreePos(rawat.position, tc.position)) {
return true;
}
}
return false;
}
private static boolean contentEquals(Name n1, Name n2) {
// Views of underlying bytes, not copies as with Name#contentEquals
ByteBuffer b1 = ByteBuffer.wrap(n1.getByteArray(), n1.getByteOffset(), n1.getByteLength());
ByteBuffer b2 = ByteBuffer.wrap(n2.getByteArray(), n2.getByteOffset(), n2.getByteLength());
return b1.equals(b2);
}
/**
* Compare two TypeAnnotationPositions for equality.
*
* @param p1 the first position
* @param p2 the second position
* @return true, iff the two positions are equal
*/
public static boolean isSameTAPosition(TypeAnnotationPosition p1,
TypeAnnotationPosition p2) {
return isSameTAPositionExceptTreePos(p1, p2) && p1.pos == p2.pos;
}
public static boolean isSameTAPositionExceptTreePos(TypeAnnotationPosition p1,
TypeAnnotationPosition p2) {
return p1.isValidOffset == p2.isValidOffset &&
p1.bound_index == p2.bound_index &&
p1.exception_index == p2.exception_index &&
p1.location.equals(p2.location) &&
Arrays.equals(p1.lvarIndex, p2.lvarIndex) &&
Arrays.equals(p1.lvarLength, p2.lvarLength) &&
Arrays.equals(p1.lvarOffset, p2.lvarOffset) &&
p1.offset == p2.offset &&
p1.onLambda == p2.onLambda &&
p1.parameter_index == p2.parameter_index &&
p1.type == p2.type &&
p1.type_index == p2.type_index;
}
/**
* Returns a newly created Attribute.Compound corresponding to an
* argument AnnotationMirror.
*
* @param am an AnnotationMirror, which may be part of an AST or an internally
* created subclass
* @return a new Attribute.Compound corresponding to the AnnotationMirror
*/
public static Attribute.Compound createCompoundFromAnnotationMirror(ProcessingEnvironment env,
AnnotationMirror am) {
// Create a new Attribute to match the AnnotationMirror.
List> values = List.nil();
for (Map.Entry entry :
am.getElementValues().entrySet()) {
Attribute attribute = attributeFromAnnotationValue(env, entry.getKey(), entry.getValue());
values = values.append(new Pair<>((Symbol.MethodSymbol)entry.getKey(),
attribute));
}
return new Attribute.Compound((Type.ClassType)am.getAnnotationType(), values);
}
/**
* Returns a newly created Attribute.TypeCompound corresponding to an
* argument AnnotationMirror.
*
* @param am an AnnotationMirror, which may be part of an AST or an internally
* created subclass
* @param tapos the type annotation position to use
* @return a new Attribute.TypeCompound corresponding to the AnnotationMirror
*/
public static Attribute.TypeCompound createTypeCompoundFromAnnotationMirror(ProcessingEnvironment env,
AnnotationMirror am, TypeAnnotationPosition tapos) {
// Create a new Attribute to match the AnnotationMirror.
List> values = List.nil();
for (Map.Entry entry :
am.getElementValues().entrySet()) {
Attribute attribute = attributeFromAnnotationValue(env, entry.getKey(), entry.getValue());
values = values.append(new Pair<>((Symbol.MethodSymbol)entry.getKey(),
attribute));
}
return new Attribute.TypeCompound((Type.ClassType)am.getAnnotationType(), values, tapos);
}
/**
* Returns a newly created Attribute corresponding to an argument
* AnnotationValue.
*
* @param meth the ExecutableElement that is assigned the value, needed for empty arrays
* @param av an AnnotationValue, which may be part of an AST or an internally
* created subclass
* @return a new Attribute corresponding to the AnnotationValue
*/
public static Attribute attributeFromAnnotationValue(ProcessingEnvironment env, ExecutableElement meth, AnnotationValue av) {
return av.accept(new AttributeCreator(env, meth), null);
}
private static class AttributeCreator implements AnnotationValueVisitor {
private final ProcessingEnvironment processingEnv;
private final Types modelTypes;
private final Elements elements;
private final com.sun.tools.javac.code.Types javacTypes;
private final ExecutableElement meth;
public AttributeCreator(ProcessingEnvironment env, ExecutableElement meth) {
this.processingEnv = env;
Context context = ((JavacProcessingEnvironment)env).getContext();
this.elements = env.getElementUtils();
this.modelTypes = env.getTypeUtils();
this.javacTypes = com.sun.tools.javac.code.Types.instance(context);
this.meth = meth;
}
@Override
public Attribute visit(AnnotationValue av, Void p) {
return av.accept(this, p);
}
@Override
public Attribute visit(AnnotationValue av) {
return visit(av, null);
}
@Override
public Attribute visitBoolean(boolean b, Void p) {
TypeMirror booleanType = modelTypes.getPrimitiveType(TypeKind.BOOLEAN);
return new Attribute.Constant((Type) booleanType, b ? 1 : 0);
}
@Override
public Attribute visitByte(byte b, Void p) {
TypeMirror byteType = modelTypes.getPrimitiveType(TypeKind.BYTE);
return new Attribute.Constant((Type)byteType, b);
}
@Override
public Attribute visitChar(char c, Void p) {
TypeMirror charType = modelTypes.getPrimitiveType(TypeKind.CHAR);
return new Attribute.Constant((Type)charType, c);
}
@Override
public Attribute visitDouble(double d, Void p) {
TypeMirror doubleType = modelTypes.getPrimitiveType(TypeKind.DOUBLE);
return new Attribute.Constant((Type)doubleType, d);
}
@Override
public Attribute visitFloat(float f, Void p) {
TypeMirror floatType = modelTypes.getPrimitiveType(TypeKind.FLOAT);
return new Attribute.Constant((Type)floatType, f);
}
@Override
public Attribute visitInt(int i, Void p) {
TypeMirror intType = modelTypes.getPrimitiveType(TypeKind.INT);
return new Attribute.Constant((Type)intType, i);
}
@Override
public Attribute visitLong(long i, Void p) {
TypeMirror longType = modelTypes.getPrimitiveType(TypeKind.LONG);
return new Attribute.Constant((Type)longType, i);
}
@Override
public Attribute visitShort(short s, Void p) {
TypeMirror shortType = modelTypes.getPrimitiveType(TypeKind.SHORT);
return new Attribute.Constant((Type)shortType, s);
}
@Override
public Attribute visitString(String s, Void p) {
TypeMirror stringType = elements.getTypeElement("java.lang.String").asType();
return new Attribute.Constant((Type)stringType, s);
}
@Override
public Attribute visitType(TypeMirror t, Void p) {
if (t instanceof Type) {
return new Attribute.Class(javacTypes, (Type)t);
}
assert false : "Unexpected type of TypeMirror: " + t.getClass();
return null;
}
@Override
public Attribute visitEnumConstant(VariableElement c, Void p) {
if (c instanceof Symbol.VarSymbol) {
Symbol.VarSymbol sym = (Symbol.VarSymbol) c;
if (sym.getKind() == ElementKind.ENUM_CONSTANT) {
return new Attribute.Enum(sym.type, sym);
}
}
assert false : "Unexpected type of VariableElement: " + c.getClass();
return null;
}
@Override
public Attribute visitAnnotation(AnnotationMirror a, Void p) {
return createCompoundFromAnnotationMirror(processingEnv, a);
}
@Override
public Attribute visitArray(java.util.List vals, Void p) {
if (!vals.isEmpty()) {
List valAttrs = List.nil();
for (AnnotationValue av : vals) {
valAttrs = valAttrs.append(av.accept(this, p));
}
ArrayType arrayType = modelTypes.getArrayType(valAttrs.get(0).type);
return new Attribute.Array((Type)arrayType, valAttrs);
} else {
return new Attribute.Array((Type) meth.getReturnType(), List.nil());
}
}
@Override
public Attribute visitUnknown(AnnotationValue av, Void p) {
assert false : "Unexpected type of AnnotationValue: " + av.getClass();
return null;
}
}
/**
* An interface to abstract a Java 8 and a Java 9 version of how
* to get a RET reference.
* These methods must then be implemented using reflection in order to
* compile in either setting.
* Note that we cannot use lambda for this as long as we want to
* support Java 7.
*/
interface Call8or9 {
RET call8() throws Throwable;
RET call9() throws Throwable;
}
/**
* Use the SourceVersion to decide whether to call the Java 8 or Java 9 version.
* Catch all exceptions and abort if one occurs - the reflection code should
* never break once fully debugged.
*
* @param tc the TAPCall abstraction to encapsulate two methods
* @return the created TypeAnnotationPosition
*/
private static RET call8or9(Call8or9 tc) {
try {
boolean hasNine;
try {
hasNine = SourceVersion.valueOf("RELEASE_9") != null;
} catch (IllegalArgumentException iae) {
hasNine = false;
}
if (hasNine) {
return tc.call9();
} else {
boolean hasEight;
try {
hasEight = SourceVersion.valueOf("RELEASE_8") != null;
} catch (IllegalArgumentException iae) {
hasEight = false;
}
if (hasEight) {
return tc.call8();
} else {
assert false : "Checker Framework needs a Java 8 or 9 javac.";
return null;
}
}
} catch (Throwable t) {
assert false : "Checker Framework internal error: " + t;
t.printStackTrace();
return null;
}
}
public static TypeAnnotationPosition unknownTAPosition() {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException {
return TypeAnnotationPosition.class.newInstance();
}
@Override
public TypeAnnotationPosition call9() throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getField("unknown")
.get(null);
}
}
);
}
public static TypeAnnotationPosition methodReturnTAPosition(final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.METHOD_RETURN);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodReturn", int.class)
.invoke(null, pos);
}
}
);
}
public static TypeAnnotationPosition methodReceiverTAPosition(final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.METHOD_RECEIVER);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodReceiver", int.class)
.invoke(null, pos);
}
}
);
}
public static TypeAnnotationPosition methodParameterTAPosition(final int pidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.METHOD_FORMAL_PARAMETER);
TypeAnnotationPosition.class.getField("parameter_index").set(tapos, pidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodParameter", int.class, int.class)
.invoke(null, pidx, pos);
}
}
);
}
public static TypeAnnotationPosition methodThrowsTAPosition(final int tidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.THROWS);
TypeAnnotationPosition.class.getField("type_index").set(tapos, tidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodThrows", List.class, JCLambda.class, int.class, int.class)
.invoke(null, TypeAnnotationPosition.class.getField("emptyPath").get(null), null, tidx, pos);
}
}
);
}
public static TypeAnnotationPosition fieldTAPosition(final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.FIELD);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("field", int.class)
.invoke(null, pos);
}
}
);
}
public static TypeAnnotationPosition classExtendsTAPosition(final int implidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.CLASS_EXTENDS);
TypeAnnotationPosition.class.getField("type_index").set(tapos, implidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("classExtends", int.class, int.class)
.invoke(null, implidx, pos);
}
}
);
}
public static TypeAnnotationPosition typeParameterTAPosition(final int tpidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.CLASS_TYPE_PARAMETER);
TypeAnnotationPosition.class.getField("parameter_index").set(tapos, tpidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("typeParameter", List.class, JCLambda.class, int.class, int.class)
.invoke(null, TypeAnnotationPosition.class.getField("emptyPath").get(null), null, tpidx, pos);
}
}
);
}
public static TypeAnnotationPosition methodTypeParameterTAPosition(final int tpidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.METHOD_TYPE_PARAMETER);
TypeAnnotationPosition.class.getField("parameter_index").set(tapos, tpidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodTypeParameter", List.class, JCLambda.class, int.class, int.class)
.invoke(null, TypeAnnotationPosition.class.getField("emptyPath").get(null), null, tpidx, pos);
}
}
);
}
public static TypeAnnotationPosition typeParameterBoundTAPosition(final int tpidx, final int bndidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.CLASS_TYPE_PARAMETER_BOUND);
TypeAnnotationPosition.class.getField("parameter_index").set(tapos, tpidx);
TypeAnnotationPosition.class.getField("bound_index").set(tapos, bndidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("typeParameterBound", List.class, JCLambda.class, int.class, int.class, int.class)
.invoke(null, TypeAnnotationPosition.class.getField("emptyPath").get(null), null, tpidx, bndidx, pos);
}
}
);
}
public static TypeAnnotationPosition methodTypeParameterBoundTAPosition(final int tpidx, final int bndidx, final int pos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition tapos = TypeAnnotationPosition.class.newInstance();
TypeAnnotationPosition.class.getField("type").set(tapos, TargetType.METHOD_TYPE_PARAMETER_BOUND);
TypeAnnotationPosition.class.getField("parameter_index").set(tapos, tpidx);
TypeAnnotationPosition.class.getField("bound_index").set(tapos, bndidx);
TypeAnnotationPosition.class.getField("pos").set(tapos, pos);
return tapos;
}
@Override
public TypeAnnotationPosition call9() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("methodTypeParameterBound", List.class, JCLambda.class, int.class, int.class, int.class)
.invoke(null, TypeAnnotationPosition.class.getField("emptyPath").get(null), null, tpidx, bndidx, pos);
}
}
);
}
public static TypeAnnotationPosition copyTAPosition(final TypeAnnotationPosition tapos) {
return call8or9(
new Call8or9() {
@Override
public TypeAnnotationPosition call8() throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
return copyTAPosition8(tapos);
}
@Override
public TypeAnnotationPosition call9() throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, InvocationTargetException, NoSuchMethodException {
return (TypeAnnotationPosition) TypeAnnotationPosition.class
.getMethod("copy", TypeAnnotationPosition.class)
.invoke(null, tapos);
}
}
);
}
private static TypeAnnotationPosition copyTAPosition8(TypeAnnotationPosition tapos) throws InstantiationException, IllegalAccessException, IllegalArgumentException, NoSuchFieldException, SecurityException {
TypeAnnotationPosition res = TypeAnnotationPosition.class.newInstance();
res.isValidOffset = tapos.isValidOffset;
TypeAnnotationPosition.class.getField("bound_index").set(res, tapos.bound_index);
res.exception_index = tapos.exception_index;
res.location = List.from(tapos.location);
if (tapos.lvarIndex != null) {
res.lvarIndex = Arrays.copyOf(tapos.lvarIndex, tapos.lvarIndex.length);
}
if (tapos.lvarLength != null) {
res.lvarLength = Arrays.copyOf(tapos.lvarLength, tapos.lvarLength.length);
}
if (tapos.lvarOffset != null) {
res.lvarOffset = Arrays.copyOf(tapos.lvarOffset, tapos.lvarOffset.length);
}
res.offset = tapos.offset;
TypeAnnotationPosition.class.getField("onLambda").set(res, tapos.onLambda);
TypeAnnotationPosition.class.getField("parameter_index").set(res, tapos.parameter_index);
TypeAnnotationPosition.class.getField("pos").set(res, tapos.pos);
TypeAnnotationPosition.class.getField("type").set(res, tapos.type);
TypeAnnotationPosition.class.getField("type_index").set(res, tapos.type_index);
return res;
}
public static Type unannotatedType(final Type in) {
return call8or9(
new Call8or9() {
@Override
public Type call8() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
return (Type) Type.class
.getMethod("unannotatedType")
.invoke(in);
}
@Override
public Type call9() {
return in;
}
}
);
}
}