* @param msgHandler
* @return list of AjAttributes
*/
- public static List readAj5ClassAttributes(AsmManager model, JavaClass javaClass, ReferenceType type, ISourceContext context,
- IMessageHandler msgHandler, boolean isCodeStyleAspect) {
+ public static List<AjAttribute> readAj5ClassAttributes(AsmManager model, JavaClass javaClass, ReferenceType type,
+ ISourceContext context, IMessageHandler msgHandler, boolean isCodeStyleAspect) {
boolean ignoreThisClass = javaClass.getClassName().charAt(0) == 'o'
&& javaClass.getClassName().startsWith("org.aspectj.lang.annotation");
if (ignoreThisClass) {
}
private boolean alreadyDefined(LazyClassGen clazz, LazyMethodGen mg) {
- for (Iterator i = clazz.getMethodGens().iterator(); i.hasNext();) {
- LazyMethodGen existing = (LazyMethodGen) i.next();
+ for (Iterator<LazyMethodGen> i = clazz.getMethodGens().iterator(); i.hasNext();) {
+ LazyMethodGen existing = i.next();
if (signaturesMatch(mg, existing)) {
if (!mg.isAbstract() && existing.isAbstract()) {
i.remove();
boolean didSomething = false; // set if we build any bridge methods
// So what methods do we have right now in this class?
- List /* LazyMethodGen */methods = clazz.getMethodGens();
+ List<LazyMethodGen> methods = clazz.getMethodGens();
// Keep a set of all methods from this type - it'll help us to check if
// bridge methods
// have already been created, we don't want to do it twice!
- Set methodsSet = new HashSet();
+ Set<String> methodsSet = new HashSet<String>();
for (int i = 0; i < methods.size(); i++) {
- LazyMethodGen aMethod = (LazyMethodGen) methods.get(i);
+ LazyMethodGen aMethod = methods.get(i);
methodsSet.add(aMethod.getName() + aMethod.getSignature()); // e.g.
// "foo(Ljava/lang/String;)V"
}
for (int i = 0; i < methods.size(); i++) {
// This is the local method that we *might* have to bridge to
- LazyMethodGen bridgeToCandidate = (LazyMethodGen) methods.get(i);
+ LazyMethodGen bridgeToCandidate = methods.get(i);
if (bridgeToCandidate.isBridgeMethod()) {
continue; // Doh!
}
// for (Iterator iter = itdsForMethodAndConstructor.iterator(); iter.hasNext();) {
// BcelTypeMunger methodctorMunger = (BcelTypeMunger) iter.next();
ResolvedMember unMangledInterMethod = methodctorMunger.getSignature();
- List worthRetrying = new ArrayList();
+ List<DeclareAnnotation> worthRetrying = new ArrayList<DeclareAnnotation>();
boolean modificationOccured = false;
- for (Iterator iter2 = decaMCs.iterator(); iter2.hasNext();) {
- DeclareAnnotation decaMC = (DeclareAnnotation) iter2.next();
+ for (Iterator<DeclareAnnotation> iter2 = decaMCs.iterator(); iter2.hasNext();) {
+ DeclareAnnotation decaMC = iter2.next();
if (decaMC.matches(unMangledInterMethod, world)) {
LazyMethodGen annotationHolder = locateAnnotationHolderForMethodCtorMunger(clazz, methodctorMunger);
if (annotationHolder == null
while (!worthRetrying.isEmpty() && modificationOccured) {
modificationOccured = false;
- List forRemoval = new ArrayList();
- for (Iterator iter2 = worthRetrying.iterator(); iter2.hasNext();) {
- DeclareAnnotation decaMC = (DeclareAnnotation) iter2.next();
+ List<DeclareAnnotation> forRemoval = new ArrayList<DeclareAnnotation>();
+ for (Iterator<DeclareAnnotation> iter2 = worthRetrying.iterator(); iter2.hasNext();) {
+ DeclareAnnotation decaMC = iter2.next();
if (decaMC.matches(unMangledInterMethod, world)) {
LazyMethodGen annotationHolder = locateAnnotationHolderForFieldMunger(clazz, methodctorMunger);
if (doesAlreadyHaveAnnotation(annotationHolder, unMangledInterMethod, decaMC, reportedErrors)) {
}
boolean isChanged = false;
- List itdFields = getITDSubset(clazz, ResolvedTypeMunger.Field);
+ List<ConcreteTypeMunger> itdFields = getITDSubset(clazz, ResolvedTypeMunger.Field);
if (itdFields != null) {
isChanged = weaveAtFieldRepeatedly(allDecafs, itdFields, reportedProblems);
}
}
private boolean doesAlreadyHaveAnnotation(LazyMethodGen rm, ResolvedMember itdfieldsig, DeclareAnnotation deca,
- List reportedProblems) {
+ List<Integer> reportedProblems) {
if (rm != null && rm.hasAnnotation(deca.getAnnotationType())) {
if (world.getLint().elementAlreadyAnnotated.isEnabled()) {
Integer uniqueID = new Integer(rm.hashCode() * deca.hashCode());
// search for 'returns' and make them jump to the
// aload_<n>,monitorexit
InstructionHandle walker = body.getStart();
- List rets = new ArrayList();
+ List<InstructionHandle> rets = new ArrayList<InstructionHandle>();
while (walker != null) {
if (walker.getInstruction().isReturnInstruction()) {
rets.add(walker);
// the load instruction
// (so we never jump over the monitorexit logic)
- for (Iterator iter = rets.iterator(); iter.hasNext();) {
- InstructionHandle element = (InstructionHandle) iter.next();
+ for (Iterator<InstructionHandle> iter = rets.iterator(); iter.hasNext();) {
+ InstructionHandle element = iter.next();
InstructionList monitorExitBlock = new InstructionList();
monitorExitBlock.append(InstructionFactory.createLoad(enclosingClassType, slotForLockObject));
monitorExitBlock.append(InstructionConstants.MONITOREXIT);
// search for 'returns' and make them to the aload_<n>,monitorexit
InstructionHandle walker = body.getStart();
- List rets = new ArrayList();
+ List<InstructionHandle> rets = new ArrayList<InstructionHandle>();
while (walker != null) { // !walker.equals(body.getEnd())) {
if (walker.getInstruction().isReturnInstruction()) {
rets.add(walker);
// load instruction
// (so we never jump over the monitorexit logic)
- for (Iterator iter = rets.iterator(); iter.hasNext();) {
- InstructionHandle element = (InstructionHandle) iter.next();
+ for (Iterator<InstructionHandle> iter = rets.iterator(); iter.hasNext();) {
+ InstructionHandle element = iter.next();
// System.err.println("Adding monitor exit block at "+element
// );
InstructionList monitorExitBlock = new InstructionList();
}
}
- private boolean matchInit(LazyMethodGen mg, List shadowAccumulator) {
+ private boolean matchInit(LazyMethodGen mg, List<BcelShadow> shadowAccumulator) {
BcelShadow enclosingShadow;
// XXX the enclosing join point is wrong for things before ignoreMe.
InstructionHandle superOrThisCall = findSuperOrThisCall(mg);
}
private void matchInvokeInstruction(LazyMethodGen mg, InstructionHandle ih, InvokeInstruction invoke,
- BcelShadow enclosingShadow, List shadowAccumulator) {
+ BcelShadow enclosingShadow, List<BcelShadow> shadowAccumulator) {
String methodName = invoke.getName(cpg);
if (methodName.startsWith(NameMangler.PREFIX)) {
Member jpSig = world.makeJoinPointSignatureForMethodInvocation(clazz, invoke);
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignature.FormalTypeParameter;
import org.aspectj.weaver.AbstractReferenceTypeDelegate;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
} catch (RuntimeException re) {
throw new RuntimeException("Problem processing attributes in " + javaClass.getFileName(), re);
}
- List pointcuts = new ArrayList();
- typeMungers = new ArrayList();
- declares = new ArrayList();
+ List<ResolvedPointcutDefinition> pointcuts = new ArrayList<ResolvedPointcutDefinition>();
+ typeMungers = new ArrayList<ConcreteTypeMunger>();
+ declares = new ArrayList<Declare>();
processAttributes(l, pointcuts, false);
l = AtAjAttributes.readAj5ClassAttributes(((BcelWorld) getResolvedTypeX().getWorld()).getModelAsAsmManager(), javaClass,
getResolvedTypeX(), getResolvedTypeX().getSourceContext(), msgHandler, isCodeStyleAspect);
if (pointcuts.size() == 0) {
this.pointcuts = ResolvedPointcutDefinition.NO_POINTCUTS;
} else {
- this.pointcuts = (ResolvedPointcutDefinition[]) pointcuts.toArray(new ResolvedPointcutDefinition[pointcuts.size()]);
+ this.pointcuts = pointcuts.toArray(new ResolvedPointcutDefinition[pointcuts.size()]);
}
resolveAnnotationDeclares(l);
/**
* Extra processing step needed because declares that come from annotations are not pre-resolved. We can't do the resolution
* until *after* the pointcuts have been resolved.
- *
- * @param attributeList
*/
- private void resolveAnnotationDeclares(List attributeList) {
+ private void resolveAnnotationDeclares(List<AjAttribute> attributeList) {
FormalBinding[] bindings = new org.aspectj.weaver.patterns.FormalBinding[0];
IScope bindingScope = new BindingScope(getResolvedTypeX(), getResolvedTypeX().getSourceContext(), bindings);
- for (Iterator iter = attributeList.iterator(); iter.hasNext();) {
- AjAttribute a = (AjAttribute) iter.next();
+ for (Iterator<AjAttribute> iter = attributeList.iterator(); iter.hasNext();) {
+ AjAttribute a = iter.next();
if (a instanceof AjAttribute.DeclareAttribute) {
Declare decl = (((AjAttribute.DeclareAttribute) a).getDeclare());
if (decl instanceof DeclareErrorOrWarning) {
for (int i = annotations.length - 1; i >= 0; i--) {
AnnotationAJ ax = annotations[i];
if (ax.getTypeName().equals(UnresolvedType.AT_RETENTION.getName())) {
- List values = ((BcelAnnotation) ax).getBcelAnnotation().getValues();
- for (Iterator it = values.iterator(); it.hasNext();) {
- NameValuePair element = (NameValuePair) it.next();
+ List<NameValuePair> values = ((BcelAnnotation) ax).getBcelAnnotation().getValues();
+ for (Iterator<NameValuePair> it = values.iterator(); it.hasNext();) {
+ NameValuePair element = it.next();
EnumElementValue v = (EnumElementValue) element.getValue();
retentionPolicy = v.getEnumValueString();
return retentionPolicy;
// proceeding with resolution.
GenericSignature.FormalTypeParameter[] extraFormals = getFormalTypeParametersFromOuterClass();
if (extraFormals.length > 0) {
- List allFormals = new ArrayList();
+ List<FormalTypeParameter> allFormals = new ArrayList<FormalTypeParameter>();
for (int i = 0; i < formalsForResolution.length; i++) {
allFormals.add(formalsForResolution[i]);
}
import org.aspectj.weaver.NameMangler;
import org.aspectj.weaver.NewConstructorTypeMunger;
import org.aspectj.weaver.NewFieldTypeMunger;
+import org.aspectj.weaver.NewMemberClassTypeMunger;
import org.aspectj.weaver.NewMethodTypeMunger;
import org.aspectj.weaver.NewParentTypeMunger;
import org.aspectj.weaver.PerObjectInterfaceTypeMunger;
changed = mungeNewField(weaver, (NewFieldTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.Method) {
changed = mungeNewMethod(weaver, (NewMethodTypeMunger) munger);
+ } else if (munger.getKind() == ResolvedTypeMunger.InnerClass) {
+ changed = mungeNewMemberType(weaver, (NewMemberClassTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.MethodDelegate2) {
changed = mungeMethodDelegate(weaver, (MethodDelegateTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.FieldHost) {
// hidden
} else {
ResolvedMember declaredSig = munger.getSignature();
+ String fromString = fName + ":'" + declaredSig + "'";
// if (declaredSig==null) declaredSig= munger.getSignature();
+ String kindString = munger.getKind().toString().toLowerCase();
+ if (kindString.equals("innerclass")) {
+ kindString = "member class";
+ fromString = fName;
+ }
weaver.getWorld().getMessageHandler().handleMessage(
WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ITD, new String[] {
- weaver.getLazyClassGen().getType().getName(), tName, munger.getKind().toString().toLowerCase(),
- getAspectType().getName(), fName + ":'" + declaredSig + "'" }, weaver.getLazyClassGen()
- .getClassName(), getAspectType().getName()));
+ weaver.getLazyClassGen().getType().getName(), tName, kindString, getAspectType().getName(),
+ fromString }, weaver.getLazyClassGen().getClassName(), getAspectType().getName()));
}
}
return !bcelObjectType.isInterface();
}
+ private boolean mungeNewMemberType(BcelClassWeaver classWeaver, NewMemberClassTypeMunger munger) {
+ World world = classWeaver.getWorld();
+ ResolvedType onType = world.resolve(munger.getTargetType());
+ if (onType.isRawType()) {
+ onType = onType.getGenericType();
+ }
+ return onType.equals(classWeaver.getLazyClassGen().getType());
+ }
+
private boolean mungeNewMethod(BcelClassWeaver classWeaver, NewMethodTypeMunger munger) {
World world = classWeaver.getWorld();
// These four are setup by prepareForWeave
private transient List<ShadowMunger> shadowMungerList = null;
- private transient List typeMungerList = null;
+ private transient List<ConcreteTypeMunger> typeMungerList = null;
private transient List lateTypeMungerList = null;
private transient List declareParentsList = null;
String name = jc.getClassName();
ResolvedType type = world.resolve(name);
if (type.isAspect()) {
- Collection/* ShadowMunger */shadowMungers = customMungerFactory.createCustomShadowMungers(type);
+ Collection<ShadowMunger> shadowMungers = customMungerFactory.createCustomShadowMungers(type);
if (shadowMungers != null) {
shadowMungerList.addAll(shadowMungers);
}
- Collection/* ConcreteTypeMunger */typeMungers = customMungerFactory.createCustomTypeMungers(type);
+ Collection<ConcreteTypeMunger> typeMungers = customMungerFactory.createCustomTypeMungers(type);
if (typeMungers != null) {
typeMungerList.addAll(typeMungers);
}
if (onType.isRawType() || onType.isParameterizedType()) {
onType = onType.getGenericType();
}
- for (Iterator i = typeMungerList.iterator(); i.hasNext();) {
- ConcreteTypeMunger m = (ConcreteTypeMunger) i.next();
+ for (ConcreteTypeMunger m : typeMungerList) {
if (!m.isLateMunger() && m.matches(onType)) {
onType.addInterTypeMunger(m, false);
}
public static List<AjAttribute> readAjAttributes(String classname, Attribute[] as, ISourceContext context, World w,
AjAttribute.WeaverVersionInfo version, ConstantPoolReader dataDecompressor) {
- List<AjAttribute>
l = new ArrayList<AjAttribute>();
+ List<AjAttribute>
attributes = new ArrayList<AjAttribute>();
// first pass, look for version
List<Unknown> forSecondPass = new ArrayList<Unknown>();
String name = a.getName();
AjAttribute attr = AjAttribute.read(version, name, a.getBytes(), context, w, dataDecompressor);
if (attr != null) {
- l.add(attr);
+ attributes.add(attr);
}
}
- return l;
+ return attributes;
}
/*
projects / aspectj.git / commitdiff