/** * Creates a sensible unresolvedtype from some signature, for example: signature = LIGuard<TT;>; bound = toString=IGuard<T> * sig=PIGuard<TT;>; sigErasure=LIGuard; kind=parameterized */ static UnresolvedType convertSigToType(String aSignature) { UnresolvedType bound = null; int startOfParams = aSignature.indexOf('<'); if (startOfParams == -1) { bound = UnresolvedType.forSignature(aSignature); } else { int endOfParams = aSignature.lastIndexOf('>'); String signatureErasure = "L" + aSignature.substring(1, startOfParams) + ";"; UnresolvedType[] typeParams = createTypeParams(aSignature.substring(startOfParams + 1, endOfParams)); bound = new UnresolvedType("P" + aSignature.substring(1), signatureErasure, typeParams); } return bound; }
@Override public boolean equals(Object other) { if (other instanceof ResolvedType) { return this == other; } else { return super.equals(other); } }
public static UnresolvedType forRawTypeName(String name) { UnresolvedType ret = UnresolvedType.forName(name); ret.typeKind = TypeKind.RAW; return ret; }
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; }
public UnresolvedType getRawType() { return UnresolvedType.forSignature(getErasureSignature()); }
throw new RuntimeException(jc.getClassName() + "!=" + classname); String signature = UnresolvedType.forName(jc.getClassName()).getSignature(); ReferenceType rawType = ReferenceType.fromTypeX(UnresolvedType.forRawTypeName(jc.getClassName()), this); ret = buildBcelDelegate(rawType, jc, artificial, true); ReferenceType genericRefType = new ReferenceType(UnresolvedType.forGenericTypeSignature(signature, ret.getDeclaredGenericSignature()), this); rawType.setDelegate(ret);
public void exposeType(UnresolvedType typeToExpose) { if (ResolvedType.isMissing(typeToExpose)) { return; } if (typeToExpose.isParameterizedType() || typeToExpose.isRawType()) { if (typeToExpose instanceof ResolvedType) { typeToExpose = ((ResolvedType) typeToExpose).getGenericType(); } else { typeToExpose = UnresolvedType.forSignature(typeToExpose.getErasureSignature()); } } // Check we haven't already got a munger for this: String signatureToLookFor = typeToExpose.getSignature(); for (Iterator<ConcreteTypeMunger> iterator = typeMungers.iterator(); iterator.hasNext();) { ConcreteTypeMunger cTM = iterator.next(); ResolvedTypeMunger rTM = cTM.getMunger(); if (rTM != null && rTM instanceof ExposeTypeMunger) { String exposedType = ((ExposeTypeMunger) rTM).getExposedTypeSignature(); if (exposedType.equals(signatureToLookFor)) { return; // dont need to bother } } } addTypeMunger(world.getWeavingSupport().concreteTypeMunger(new ExposeTypeMunger(typeToExpose), inAspect)); // ResolvedMember member = new ResolvedMemberImpl( // Member.STATIC_INITIALIZATION, typeToExpose, 0, UnresolvedType.VOID, // "<clinit>", UnresolvedType.NONE); // addTypeMunger(world.concreteTypeMunger( // new PrivilegedAccessMunger(member), inAspect)); }
/** * Returns a UnresolvedType object representing the effective outermost enclosing type for a name type. For all other types, * this will return the type itself. * * The only guarantee is given in JLS 13.1 where code generated according to those rules will have type names that can be split * apart in this way. * * @return the outermost enclosing UnresolvedType object or this. */ public UnresolvedType getOutermostType() { if (isArray() || isPrimitiveType()) { return this; } String sig = getErasureSignature(); int dollar = sig.indexOf('$'); if (dollar != -1) { return UnresolvedType.forSignature(sig.substring(0, dollar) + ';'); } else { return this; } }
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; }
private UnresolvedType toUnresolvedType(Class clazz) { if (clazz.isArray()) { return UnresolvedType.forSignature(clazz.getName().replace('.', '/')); } else { return UnresolvedType.forName(clazz.getName()); } }
return new UnresolvedType(signature, signatureErasure, UnresolvedType.NONE); } else { int endOfParams = locateMatchingEndAngleBracket(signature, startOfParams); s.append('<'); for (UnresolvedType typeParameter : typeParams) { s.append(typeParameter.getSignature()); return new UnresolvedType(signature, signatureErasure, typeParams); return new UnresolvedType(signature, signature.substring(0, dims) + componentType.getErasureSignature()); } else if (signature.length() == 1) { // could be a primitive switch (firstChar) { return new UnresolvedType(signature); } else { int endOfParams = locateMatchingEndAngleBracket(signature, leftAngleBracket); s.append('<'); for (UnresolvedType typeParameter : typeParams) { s.append(typeParameter.getSignature()); return new UnresolvedType(signature, signatureErasure, typeParams); return new UnresolvedType(signature);
annotationTypes[i] = world.resolve(UnresolvedType.forSignature(anns[i].getTypeSignature())); annotationTypes[i] = UnresolvedType.forName(anns[i].annotationType().getName()).resolve(world);
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 ResolvedPointcutDefinition findPointcut(String name) { for (Iterator<ResolvedMember> i = getPointcuts(); i.hasNext();) { ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next(); // the ResolvedPointcutDefinition can be null if there are other problems that prevented its resolution if (f != null && name.equals(f.getName())) { return f; } } // pr120521 if (!getOutermostType().equals(this)) { ResolvedType outerType = getOutermostType().resolve(world); ResolvedPointcutDefinition rpd = outerType.findPointcut(name); return rpd; } return null; // should we throw an exception here? }
private AnnotationGen buildBaseAnnotationType(ConstantPool cp,World world, String typename) { String annoname = typename; if (annoname.startsWith("@")) { annoname= annoname.substring(1); } ResolvedType annotationType = UnresolvedType.forName(annoname).resolve(world); if (!annotationType.isAnnotation()) { reportError("declare is not specifying an annotation type :"+typename); return null; } if (!annotationType.isAnnotationWithRuntimeRetention()) { reportError("declare is using an annotation type that does not have runtime retention: "+typename); return null; } List<NameValuePair> elems = new ArrayList<NameValuePair>(); return new AnnotationGen(new ObjectType(annoname), elems, true, cp); }
public String getDisplayName() { StringBuffer ret = new StringBuffer(); ret.append(name); if (!getFirstBound().getName().equals("java.lang.Object")) { ret.append(" extends "); ret.append(getFirstBound().getName()); if (superInterfaces != null) { for (int i = 0; i < superInterfaces.length; i++) { if (!getFirstBound().equals(superInterfaces[i])) { ret.append(" & "); ret.append(superInterfaces[i].getName()); } } } } return ret.toString(); }
/** * 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 BcelAnnotation(AnnotationGen theBcelAnnotation, World world) { super(UnresolvedType.forSignature(theBcelAnnotation.getTypeSignature()).resolve(world)); this.bcelAnnotation = theBcelAnnotation; }
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()); } }