perClause inheritance in @AJ (in ajdt module), fixed FIXME AV

13 files changed, 90 insertions, 83 deletions

diff --git a/weaver/src/org/aspectj/weaver/ResolvedTypeX.java b/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
index 5154d1aa6..52813072d 100644
--- a/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
+++ b/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
@@ -782,6 +782,7 @@ public abstract class ResolvedTypeX extends TypeX implements AnnotatedElement {
 		public void setDelegate(ConcreteName delegate) {
 			this.delegate = delegate;
 		}
+        
 		public int getEndPos() {
 			return endPos;
 		}
diff --git a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
index 595372848..164047189 100644
--- a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
+++ b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
@@ -51,6 +51,7 @@ import org.aspectj.weaver.patterns.PerTypeWithin;
 import org.aspectj.weaver.patterns.Pointcut;
 import org.aspectj.weaver.patterns.SimpleScope;
 import org.aspectj.weaver.patterns.TypePattern;
+import org.aspectj.weaver.patterns.PerFromSuper;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -177,16 +178,15 @@ public class AtAjAttributes {
                 // we don't need to look for several attribute occurence since it cannot happen as per JSR175
                 if (!isCodeStyleAspect) {
                     hasAtAspectAnnotation = handleAspectAnnotation(rvs, struct);
+                    //TODO AV - if put outside the if isCodeStyleAspect then we would enable mix style
+                    hasAtPrecedenceAnnotation = handlePrecedenceAnnotation(rvs, struct);
                 }
-                //TODO: below means mix style for @DeclarePrecedence - are we sure we want that ?
-                hasAtPrecedenceAnnotation = handlePrecedenceAnnotation(rvs, struct);
                 // there can only be one RuntimeVisible bytecode attribute
                 break;
             }
         }
 
         // basic semantic check
-        //FIXME AV TBD could be skipped and silently ignore - TBD with Andy
         if (hasAtPrecedenceAnnotation && !hasAtAspectAnnotation) {
             msgHandler.handleMessage(
                     new Message(
@@ -199,7 +199,7 @@ public class AtAjAttributes {
             // bypass what we have read
             return EMPTY_LIST;
         }
-        //FIXME turn on when ajcMightHaveAspect fixed
+        //FIXME turn on when ajcMightHaveAspect
 //        if (hasAtAspectAnnotation && type.isInterface()) {
 //            msgHandler.handleMessage(
 //                    new Message(
@@ -214,7 +214,6 @@ public class AtAjAttributes {
 //        }
 
         // the following block will not detect @Pointcut in non @Aspect types for optimization purpose
-        // FIXME AV TBD with Andy
         if (!hasAtAspectAnnotation) {
             return EMPTY_LIST;
         }
@@ -222,8 +221,7 @@ public class AtAjAttributes {
         // code style pointcuts are class attributes
         // we need to gather the @AJ pointcut right now and not at method level annotation extraction time
         // in order to be able to resolve the pointcut references later on
-        //FIXME alex loop over class super class
-        //FIXME alex can that be too slow ?
+        // we don't need to look in super class, the pointcut reference in the grammar will do it
         for (int i = 0; i < javaClass.getMethods().length; i++) {
             Method method = javaClass.getMethods()[i];
             if (method.getName().startsWith(NameMangler.PREFIX)) continue;  // already dealt with by ajc...
@@ -297,8 +295,10 @@ public class AtAjAttributes {
         // we remember if we found one @AJ annotation for minimal semantic error reporting
         // the real reporting beeing done thru AJDT and the compiler mapping @AJ to AjAtttribute
         // or thru APT
-        // FIXME AV we could actually skip the whole thing if type is not itself an @Aspect
-        // but then we would not see any warning. TBD with Andy
+        //
+        // Note: we could actually skip the whole thing if type is not itself an @Aspect
+        // but then we would not see any warning. We do bypass for pointcut but not for advice since it would
+        // be too silent.
         boolean hasAtAspectJAnnotation = false;
         boolean hasAtAspectJAnnotationMustReturnVoid = false;
         for (int i = 0; i < attributes.length; i++) {
@@ -392,11 +392,25 @@ public class AtAjAttributes {
     private static boolean handleAspectAnnotation(RuntimeAnnotations runtimeAnnotations, AjAttributeStruct struct) {
         Annotation aspect = getAnnotation(runtimeAnnotations, AjcMemberMaker.ASPECT_ANNOTATION);
         if (aspect != null) {
+            // semantic check for inheritance (only one level up)
+            boolean extendsAspect = false;
+            if (!"java.lang.Object".equals(struct.enclosingType.getSuperclass().getName())) {
+                if (!struct.enclosingType.getSuperclass().isAbstract() && struct.enclosingType.getSuperclass().isAspect()) {
+                    reportError("cannot extend a concrete aspect", struct);
+                    return false;
+                }
+                extendsAspect = struct.enclosingType.getSuperclass().isAspect();
+            }
+
             ElementNameValuePair aspectPerClause = getAnnotationElement(aspect, VALUE);
             final PerClause perClause;
             if (aspectPerClause == null) {
-                // defaults to singleton
-                perClause = new PerSingleton();
+                // empty value means singleton unless inherited
+                if (!extendsAspect) {
+                    perClause = new PerSingleton();
+                } else {
+                    perClause = new PerFromSuper(struct.enclosingType.getSuperclass().getPerClause().getKind());
+                }
             } else {
                 String perX = aspectPerClause.getValue().stringifyValue();
                 if (perX == null || perX.length() <= 0) {
@@ -409,13 +423,6 @@ public class AtAjAttributes {
                 // could not parse it, ignore the aspect
                 return false;
             } else {
-                // semantic check for inheritance (only one level up)
-                if (!"java.lang.Object".equals(struct.enclosingType.getSuperclass().getName())) {
-                    if (!struct.enclosingType.getSuperclass().isAbstract() && struct.enclosingType.getSuperclass().isAspect()) {
-                        reportError("cannot extend a concrete aspect", struct);
-                        return false;
-                    }
-                }
                 perClause.setLocation(struct.context, -1, -1);
                 struct.ajAttributes.add(new AjAttribute.Aspect(perClause));
                 return true;
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java b/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java
index a4727a460..e426711e5 100644
--- a/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java
+++ b/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java
@@ -48,9 +48,6 @@ import java.util.List;
  * Specific state and logic is kept in the munger ala ITD so that call/get/set pointcuts can still be matched
  * on the wrapped member thanks to the EffectiveSignature attribute.
  *
- * FIXME AV - this whole one should be skept when -XnoInline is used
- * (add breakpoint on lazyMethodGen.setCanInline to see where things happening)
- *
  * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
  */
 public class BcelAccessForInlineMunger extends BcelTypeMunger {
@@ -73,6 +70,9 @@ public class BcelAccessForInlineMunger extends BcelTypeMunger {
 
     public BcelAccessForInlineMunger(ResolvedTypeX aspectType) {
         super(null, aspectType);
+        if (aspectType.getWorld().isXnoInline()) {
+            throw new Error("This should not happen");
+        }
     }
 
     public boolean munge(BcelClassWeaver weaver) {
@@ -134,7 +134,7 @@ public class BcelAccessForInlineMunger extends BcelTypeMunger {
         InstructionHandle curr = aroundAdvice.getBody().getStart();
         InstructionHandle end = aroundAdvice.getBody().getEnd();
         ConstantPoolGen cpg = aroundAdvice.getEnclosingClass().getConstantPoolGen();
-        InstructionFactory factory = aroundAdvice.enclosingClass.getFactory();
+        InstructionFactory factory = aroundAdvice.getEnclosingClass().getFactory();
 
         boolean realizedCannotInline = false;
         while (curr != end) {
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelAdvice.java b/weaver/src/org/aspectj/weaver/bcel/BcelAdvice.java
index d3e8e9f9a..d7ba55716 100644
--- a/weaver/src/org/aspectj/weaver/bcel/BcelAdvice.java
+++ b/weaver/src/org/aspectj/weaver/bcel/BcelAdvice.java
@@ -22,6 +22,7 @@ import org.aspectj.apache.bcel.generic.InstructionFactory;
 import org.aspectj.apache.bcel.generic.InstructionHandle;
 import org.aspectj.apache.bcel.generic.InstructionList;
 import org.aspectj.apache.bcel.generic.ReferenceType;
+import org.aspectj.apache.bcel.generic.InstructionConstants;
 import org.aspectj.bridge.IMessage;
 import org.aspectj.bridge.Message;
 import org.aspectj.weaver.Advice;
@@ -142,23 +143,23 @@ public class BcelAdvice extends Advice {
         hasMatchedAtLeastOnce=true;
         BcelShadow shadow = (BcelShadow) s;
 
-        //FIXME AV ok ?
-        // callback for perObject AJC MightHaveAspect postMunge (#75442)
-        if (getConcreteAspect() != null
-                && getConcreteAspect().getPerClause() != null
-                && PerClause.PEROBJECT.equals(getConcreteAspect().getPerClause().getKind())) {
-            final PerObject clause;
-            if (getConcreteAspect().getPerClause() instanceof PerFromSuper) {
-                clause = (PerObject)((PerFromSuper) getConcreteAspect().getPerClause()).lookupConcretePerClause(getConcreteAspect());
-            } else {
-                clause = (PerObject) getConcreteAspect().getPerClause();
-            }
-            if (clause.isThis()) {
-                PerObjectInterfaceTypeMunger.registerAsAdvisedBy(s.getThisVar().getType(), getConcreteAspect());
-            } else {
-                PerObjectInterfaceTypeMunger.registerAsAdvisedBy(s.getTargetVar().getType(), getConcreteAspect());
-            }
-        }
+        //FIXME AV - see #75442, this logic is not enough so for now comment it out until we fix the bug
+//        // callback for perObject AJC MightHaveAspect postMunge (#75442)
+//        if (getConcreteAspect() != null
+//                && getConcreteAspect().getPerClause() != null
+//                && PerClause.PEROBJECT.equals(getConcreteAspect().getPerClause().getKind())) {
+//            final PerObject clause;
+//            if (getConcreteAspect().getPerClause() instanceof PerFromSuper) {
+//                clause = (PerObject)((PerFromSuper) getConcreteAspect().getPerClause()).lookupConcretePerClause(getConcreteAspect());
+//            } else {
+//                clause = (PerObject) getConcreteAspect().getPerClause();
+//            }
+//            if (clause.isThis()) {
+//                PerObjectInterfaceTypeMunger.registerAsAdvisedBy(s.getThisVar().getType(), getConcreteAspect());
+//            } else {
+//                PerObjectInterfaceTypeMunger.registerAsAdvisedBy(s.getTargetVar().getType(), getConcreteAspect());
+//            }
+//        }
 
         if (getKind() == AdviceKind.Before) {
             shadow.weaveBefore(this);
@@ -260,8 +261,6 @@ public class BcelAdvice extends Advice {
      */
     public boolean mustCheckExceptions() {
         if (getConcreteAspect() == null) {
-            //FIXME AV: not sure this is good to default to that.
-            // dig when do we reach that ie not yet concretized
             return true;
         }
         return !getConcreteAspect().isAnnotationStyleAspect();
@@ -362,19 +361,11 @@ public class BcelAdvice extends Advice {
             if (v == null) {
                 // if not @AJ aspect, go on with the regular binding handling
             	if (getConcreteAspect()==null || !getConcreteAspect().isAnnotationStyleAspect()) {
-            		continue;
+            		;
             	} else {
                     // ATAJ: for @AJ aspects, handle implicit binding of xxJoinPoint
 	                if (getKind() == AdviceKind.Around) {
 	                    il.append(closureInstantiation);
-                        //
-//                        if (canInline(shadow)) {
-//                            //FIXME ALEX? passin a boolean instead of checking there
-//                            il.append(fact.createCheckCast(
-//                                    (ReferenceType) BcelWorld.makeBcelType(TypeX.forName("org.aspectj.lang.ProceedingJoinPoint"))
-//                            ));
-//                        }
-	                    continue;
 	                } else if ("Lorg/aspectj/lang/JoinPoint$StaticPart;".equals(getSignature().getParameterTypes()[i].getSignature())) {
 	                    if ((getExtraParameterFlags() & ThisJoinPointStaticPart) != 0) {
 	                        shadow.getThisJoinPointStaticPartBcelVar().appendLoad(il, fact);
@@ -393,9 +384,16 @@ public class BcelAdvice extends Advice {
 	                        fact,
 	                        getExtraParameterType().resolve(world));
 	                } else {
-                        //FIXME AV test for that - this code  will throw an error if ProceedingJP is used in a before advice f.e. ok ??
-                        throw new Error("Should not happen - unbound advice argument at index " + i + " in [" +
-                                toString() + "]");
+                        getConcreteAspect().getWorld().getMessageHandler().handleMessage(
+                                new Message(
+                                        "use of ProceedingJoinPoint is allowed only on around advice ("
+                                        + "arg " + i + " in " + toString() + ")",
+                                        this.getSourceLocation(),
+                                        true
+                                )
+                        );
+                        // try to avoid verify error and pass in null
+                        il.append(InstructionConstants.ACONST_NULL);
 	                }
             	}
             } else {
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java b/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java
index eab392a17..5ea3a5278 100644
--- a/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java
+++ b/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java
@@ -382,8 +382,7 @@ class BcelClassWeaver implements IClassWeaver {
               isChanged = true;
 			}
         }
-        //if (! isChanged) return false;//FIXME AV - was active, WHY ?? I need to reach the lateTypeMunger
-        
+
         // now we weave all but the initialization shadows
 		for (Iterator i = methodGens.iterator(); i.hasNext();) {
 			LazyMethodGen mg = (LazyMethodGen)i.next();
@@ -404,14 +403,8 @@ class BcelClassWeaver implements IClassWeaver {
         // now proceed with late type mungers
         if (lateTypeMungers != null) {
             for (Iterator i = lateTypeMungers.iterator(); i.hasNext(); ) {
-                Object o = i.next();
-                if ( !(o instanceof BcelTypeMunger) ) {
-                    throw new Error("should not happen or what ?");//FIXME AV ??was System.err.println("surprising: " + o);
-                    //continue;
-                }
-                BcelTypeMunger munger = (BcelTypeMunger)o;
+                BcelTypeMunger munger = (BcelTypeMunger)i.next();
                 if (munger.matches(clazz.getType())) {
-                    //FIXME AV - Andy must track change by this lateMunging only and deal with a reweavable thing
                     boolean typeMungerAffectedType = munger.munge(this);
                     if (typeMungerAffectedType) {
                         isChanged = true;
@@ -420,8 +413,10 @@ class BcelClassWeaver implements IClassWeaver {
                 }
             }
         }
-        // flush to save some memory - FIXME AV - extract in a better way ?
-        PerObjectInterfaceTypeMunger.unregisterFromAsAdvisedBy(clazz.getType());
+
+        //FIXME AV - see #75442, for now this is not enough to fix the bug, comment that out until we really fix it
+//        // flush to save some memory
+//        PerObjectInterfaceTypeMunger.unregisterFromAsAdvisedBy(clazz.getType());
 
 		// finally, if we changed, we add in the introduced methods.
         if (isChanged) {
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java b/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java
index 75c46d5dd..47e814f6b 100644
--- a/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java
+++ b/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java
@@ -53,7 +53,12 @@ public class BcelObjectType extends ResolvedTypeX.ConcreteName {
     private ResolvedMember[] methods = null;
     private ResolvedTypeX[] annotationTypes = null;
     private AnnotationX[] annotations = null;
-            
+
+    // track unpackAttribute. In some case (per clause inheritance) we encounter
+    // unpacked state when calling getPerClause
+    // this whole thing would require more clean up (AV)
+    private boolean isUnpacked = false;
+
     // strangely non-lazy
     private ResolvedPointcutDefinition[] pointcuts = null;
 	private PerClause perClause = null;
@@ -191,6 +196,8 @@ public class BcelObjectType extends ResolvedTypeX.ConcreteName {
     }
 
 	private void unpackAspectAttributes() {
+        isUnpacked = true;
+
 		List pointcuts = new ArrayList();
 		typeMungers = new ArrayList();
 		declares = new ArrayList();
@@ -245,6 +252,9 @@ public class BcelObjectType extends ResolvedTypeX.ConcreteName {
 	}
 
 	public PerClause getPerClause() {
+        if (!isUnpacked) {
+            unpackAspectAttributes();
+        }
 		return perClause;
 	}
     
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelWorld.java b/weaver/src/org/aspectj/weaver/bcel/BcelWorld.java
index 218eed263..1b8a57f90 100644
--- a/weaver/src/org/aspectj/weaver/bcel/BcelWorld.java
+++ b/weaver/src/org/aspectj/weaver/bcel/BcelWorld.java
@@ -237,7 +237,6 @@ public class BcelWorld extends World implements Repository {
 	
 	protected BcelObjectType makeBcelObjectType(ResolvedTypeX.Name resolvedTypeX, JavaClass jc, boolean exposedToWeaver) {
 		BcelObjectType ret = new BcelObjectType(resolvedTypeX, jc, exposedToWeaver);
-		resolvedTypeX.setDelegate(ret);
 		return ret;
 	}
 	
@@ -274,7 +273,6 @@ public class BcelWorld extends World implements Repository {
         	nameTypeX = new ResolvedTypeX.Name(signature, this);
         }
         BcelObjectType ret = makeBcelObjectType(nameTypeX, jc, true);
-        nameTypeX.setDelegate(ret);
         typeMap.put(signature, nameTypeX);
 		return ret;
 	}
diff --git a/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java b/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java
index 8aeec7f8f..8aae4570a 100644
--- a/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java
+++ b/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java
@@ -87,8 +87,8 @@ public final class LazyMethodGen {
     private  InstructionList body; // leaving null for abstracts
     private  Attribute[]     attributes;
    // private AnnotationGen[]  annotations;
-    /* private */ final LazyClassGen    enclosingClass;   
-    private /*final*/ BcelMethod      memberView;//FIXME AV LTW
+    private final LazyClassGen enclosingClass;   
+    private BcelMethod memberView;
     int highestLineNumber = 0;
 
 	/** This is nonnull if this method is the result of an "inlining".  We currently
@@ -100,7 +100,7 @@ public final class LazyMethodGen {
 
     private int             maxLocals; 
     
-    private boolean canInline = true;//FIXME AV - ALEX? shouldn't that default to false or unknown?
+    private boolean canInline = true;
     private boolean hasExceptionHandlers;
     
     private boolean isSynthetic = false;
@@ -218,9 +218,7 @@ public final class LazyMethodGen {
 	public boolean hasAnnotation(TypeX annotationTypeX) {
 		initialize();
 		if (memberView==null) {
-            memberView = new BcelMethod(getEnclosingClass().getBcelObjectType(), getMethod());//FIXME AV LTW
-			//System.err.println("REPORT THIS! 02: Can't determine if "+getEnclosingClass().getName() + "." + this.getName() + this.getSignature()+" has annotation "+annotationTypeX);
-			//return false
+            memberView = new BcelMethod(getEnclosingClass().getBcelObjectType(), getMethod());
             return memberView.hasAnnotation(annotationTypeX);
 		}
 		return memberView.hasAnnotation(annotationTypeX);
diff --git a/weaver/src/org/aspectj/weaver/patterns/PerCflow.java b/weaver/src/org/aspectj/weaver/patterns/PerCflow.java
index 73eef47d7..b61223ccf 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PerCflow.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PerCflow.java
@@ -98,14 +98,14 @@ public class PerCflow extends PerClause {
 									inAspect, innerCflowEntries));
 
         //ATAJ: add a munger to add the aspectOf(..) to the @AJ aspects
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.isAbstract()) {
             inAspect.crosscuttingMembers.addLateTypeMunger(
                     inAspect.getWorld().makePerClauseAspect(inAspect, getKind())
             );
         }
 
         //ATAJ inline around advice support - don't use a late munger to allow around inling for itself
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.getWorld().isXnoInline()) {
             inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect));
         }
 
diff --git a/weaver/src/org/aspectj/weaver/patterns/PerObject.java b/weaver/src/org/aspectj/weaver/patterns/PerObject.java
index 31eef9ade..a9294e853 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PerObject.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PerObject.java
@@ -111,14 +111,14 @@ public class PerObject extends PerClause {
 		inAspect.crosscuttingMembers.addLateTypeMunger(world.concreteTypeMunger(munger, inAspect));
 
         //ATAJ: add a munger to add the aspectOf(..) to the @AJ aspects
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.isAbstract()) {
             inAspect.crosscuttingMembers.addLateTypeMunger(
                     inAspect.getWorld().makePerClauseAspect(inAspect, getKind())
             );
         }
 
         //ATAJ inline around advice support - don't use a late munger to allow around inling for itself
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.getWorld().isXnoInline()) {
             inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect));
         }
 
diff --git a/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java b/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java
index 385f9175c..5b3b9f954 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java
@@ -96,7 +96,7 @@ public class PerSingleton extends PerClause {
 		ret.inAspect = inAspect;
 
         //ATAJ: add a munger to add the aspectOf(..) to the @AJ aspects
-        if (!inAspect.isAbstract() && inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect()  && !inAspect.isAbstract()) {
             //TODO will those change be ok if we add a serializable aspect ?
             // dig: "can't be Serializable/Cloneable unless -XserializableAspects"
             inAspect.crosscuttingMembers.addLateTypeMunger(
@@ -105,7 +105,7 @@ public class PerSingleton extends PerClause {
         }
 
         //ATAJ inline around advice support
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.getWorld().isXnoInline()) {
             inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect));
         }
 
diff --git a/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java b/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java
index 651d192a3..bd8873e27 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java
@@ -148,14 +148,14 @@ public class PerTypeWithin extends PerClause {
 		inAspect.crosscuttingMembers.addTypeMunger(world.concreteTypeMunger(munger, inAspect));
 
         //ATAJ: add a munger to add the aspectOf(..) to the @AJ aspects
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.isAbstract()) {
             inAspect.crosscuttingMembers.addLateTypeMunger(
                     inAspect.getWorld().makePerClauseAspect(inAspect, getKind())
             );
         }
 
         //ATAJ inline around advice support - don't use a late munger to allow around inling for itself
-        if (inAspect.isAnnotationStyleAspect()) {
+        if (inAspect.isAnnotationStyleAspect() && !inAspect.getWorld().isXnoInline()) {
             inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect));
         }
 
diff --git a/weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java b/weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java
index 67bd70f3c..1eb97964f 100644
--- a/weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java
+++ b/weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java
@@ -192,8 +192,8 @@ public class WeavingAdaptor {
     }
 
 	private boolean shouldWeaveName (String name) {
-		return !((name.startsWith("org.apache.bcel.")//FIXME AV why ? bcel is wrapped in org.aspectj.
-                || name.startsWith("org.aspectj.")
+		return !((/*(name.startsWith("org.apache.bcel.")//FIXME AV why ? bcel is wrapped in org.aspectj.
+                ||*/ name.startsWith("org.aspectj.")
                 || name.startsWith("java.")
                 || name.startsWith("javax."))
                 || name.startsWith("$Proxy"));//JDK proxies