public static UnresolvedType forGenericTypeVariables(String sig, TypeVariable[] tVars) { UnresolvedType ret = UnresolvedType.forSignature(sig); ret.typeKind = TypeKind.GENERIC; ret.typeVariables = tVars; ret.signatureErasure = sig; ret.signature = ret.signatureErasure; return ret; }
/** * Constructs a UnresolvedType for each JVM bytecode type signature in an incoming array. * * @param names an array of JVM bytecode type signatures * @return an array of UnresolvedType objects. * @see #forSignature(String) */ public static UnresolvedType[] forSignatures(String[] sigs) { UnresolvedType[] ret = new UnresolvedType[sigs.length]; for (int i = 0, len = sigs.length; i < len; i++) { ret[i] = UnresolvedType.forSignature(sigs[i]); } return ret; }
/** * Read in an UnresolvedType - just read the signature and rebuild the UnresolvedType. */ public static UnresolvedType read(DataInputStream s) throws IOException { String sig = s.readUTF(); if (sig.equals(MISSING_NAME)) { return ResolvedType.MISSING; } else { // TODO isn't it a shame to build these (this method is expensive) and then chuck them away on resolution? // TODO review callers and see if they are immediately resolving it, maybe we can do something more optimal if they are return UnresolvedType.forSignature(sig); } }
public static UnresolvedType forGenericType(String name, TypeVariable[] tvbs, String genericSig) { String sig = nameToSignature(name); UnresolvedType ret = UnresolvedType.forSignature(sig); ret.typeKind = TypeKind.GENERIC; ret.typeVariables = tvbs; ret.signatureErasure = sig; return ret; }
private UnresolvedType toUnresolvedType(Class<?> clazz) { if (clazz.isArray()) { return UnresolvedType.forSignature(clazz.getName().replace('.', '/')); } else { return UnresolvedType.forName(clazz.getName()); } }
public static ResolvedMember perTypeWithinCreateAspectInstance(UnresolvedType declaringType) { // public static a.X ajc$createAspectInstance(java.lang.String) ResolvedMemberImpl rm = new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, declaringType, // return value NameMangler.PERTYPEWITHIN_CREATEASPECTINSTANCE_METHOD, new UnresolvedType[] { UnresolvedType.forSignature("Ljava/lang/String;") }, new UnresolvedType[] {}); return rm; }
public static UnresolvedType makeArray(UnresolvedType base, int dims) { StringBuffer sig = new StringBuffer(); for (int i = 0; i < dims; i++) { sig.append("["); } sig.append(base.getSignature()); return UnresolvedType.forSignature(sig.toString()); } }
private UnresolvedType toUnresolvedType(Class clazz) { if (clazz.isArray()) { return UnresolvedType.forSignature(clazz.getName().replace('.', '/')); } else { return UnresolvedType.forName(clazz.getName()); } }
public UnresolvedType getRawType() { return UnresolvedType.forSignature(getErasureSignature()); }
/** * Returns a UnresolvedType object representing the component type of this array, or null if this type does not represent an * array type. * * @return the component UnresolvedType object, or null. */ public UnresolvedType getComponentType() { if (isArray()) { return forSignature(signature.substring(1)); } else { return null; } }
public static UnresolvedType fromBcel(Type t) { return UnresolvedType.forSignature(t.getSignature()); }
public static MemberImpl field(String declaring, int mods, String name, String signature) { return field(declaring, mods, UnresolvedType.forSignature(signature), name); }
public static ResolvedType resolve(World world, Class<?> aClass) { // classes that represent arrays return a class name that is the // signature of the array type, ho-hum... String className = aClass.getName(); if (aClass.isArray()) { return world.resolve(UnresolvedType.forSignature(className.replace('.', '/'))); } else { return world.resolve(className); } }
public static ResolvedType resolveTypeInWorld(Class aClass, World aWorld) { // classes that represent arrays return a class name that is the signature of the array type, ho-hum... String className = aClass.getName(); if (aClass.isArray()) { return aWorld.resolve(UnresolvedType.forSignature(className.replace('.', '/'))); } else { return aWorld.resolve(className); } }
public BcelAnnotation(AnnotationGen theBcelAnnotation, World world) { super(UnresolvedType.forSignature(theBcelAnnotation.getTypeSignature()).resolve(world)); this.bcelAnnotation = theBcelAnnotation; }
public static ResolvedMember perTypeWithinAspectOfMethod(UnresolvedType declaringType, boolean inJava5Mode) { UnresolvedType parameterType = null; if (inJava5Mode) { parameterType = UnresolvedType.forRawTypeName("java.lang.Class"); } else { parameterType = UnresolvedType.forSignature("Ljava/lang/Class;"); } return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, declaringType, "aspectOf", new UnresolvedType[] { parameterType }); // return new ResolvedMemberImpl(Member.METHOD, // declaringType, PUBLIC_STATIC, "aspectOf", // "(Ljava/lang/Class;)" + declaringType.getSignature()); }
public static ResolvedMember perTypeWithinHasAspectMethod(UnresolvedType declaringType, boolean inJava5Mode) { UnresolvedType parameterType = null; if (inJava5Mode) { parameterType = UnresolvedType.forRawTypeName("java.lang.Class"); } else { parameterType = UnresolvedType.forSignature("Ljava/lang/Class;"); } return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, UnresolvedType.BOOLEAN, "hasAspect", new UnresolvedType[] { parameterType }); // return new ResolvedMemberImpl(Member.METHOD, // declaringType, PUBLIC_STATIC, "hasAspect", // "(Ljava/lang/Class;)Z"); }
public UnresolvedType readSignatureAsUnresolvedType() throws IOException { return UnresolvedType.forSignature(readUtf8(readShort())); }
public void addAnnotation(AnnotationGen a) { if (!hasAnnotation(UnresolvedType.forSignature(a.getTypeSignature()))) { annotations.add(new AnnotationGen(a, getConstantPool(), true)); } }
private static ResolvedType typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig, GenericSignature.FormalTypeParameter[] typeParams, World world, Map<GenericSignature.FormalTypeParameter, ReferenceType> inProgressTypeVariableResolutions) throws GenericSignatureFormatException { if (aTypeSig.isBaseType()) { return world.resolve(UnresolvedType.forSignature(((GenericSignature.BaseTypeSignature) aTypeSig).toString())); } else { return fieldTypeSignature2TypeX((GenericSignature.FieldTypeSignature) aTypeSig, typeParams, world, inProgressTypeVariableResolutions); } }