diff options
author | avasseur <avasseur> | 2005-05-03 14:43:43 +0000 |
---|---|---|
committer | avasseur <avasseur> | 2005-05-03 14:43:43 +0000 |
commit | 9e2ef17dadcfb72eb462e59d996282e0ff0da76b (patch) | |
tree | f6e29a4b3a0d1985f30acffa5a54d16abc23a527 /weaver | |
parent | a89568a77f2d3e74b0d23f3f7b0e112d7ca92d74 (diff) | |
download | aspectj-9e2ef17dadcfb72eb462e59d996282e0ff0da76b.tar.gz aspectj-9e2ef17dadcfb72eb462e59d996282e0ff0da76b.zip |
@AJ around inline + test, fix a bug in BcelClassWeaver on my way
Diffstat (limited to 'weaver')
8 files changed, 507 insertions, 6 deletions
diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java b/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java new file mode 100644 index 000000000..c174ee3cd --- /dev/null +++ b/weaver/src/org/aspectj/weaver/bcel/BcelAccessForInlineMunger.java @@ -0,0 +1,464 @@ +/******************************************************************************* + * Copyright (c) 2005 Contributors. + * All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://eclipse.org/legal/epl-v10.html + * + * Contributors: + * Alexandre Vasseur initial implementation + *******************************************************************************/ +package org.aspectj.weaver.bcel; + +import org.aspectj.apache.bcel.Constants; +import org.aspectj.apache.bcel.generic.ConstantPoolGen; +import org.aspectj.apache.bcel.generic.FieldInstruction; +import org.aspectj.apache.bcel.generic.GETFIELD; +import org.aspectj.apache.bcel.generic.GETSTATIC; +import org.aspectj.apache.bcel.generic.Instruction; +import org.aspectj.apache.bcel.generic.InstructionConstants; +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.InvokeInstruction; +import org.aspectj.apache.bcel.generic.Type; +import org.aspectj.weaver.AjAttribute; +import org.aspectj.weaver.AjcMemberMaker; +import org.aspectj.weaver.Member; +import org.aspectj.weaver.NameMangler; +import org.aspectj.weaver.ResolvedMember; +import org.aspectj.weaver.ResolvedTypeX; +import org.aspectj.weaver.Shadow; +import org.aspectj.weaver.TypeX; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; +import java.util.List; + +/** + * Looks for all access to method or field that are not public within the body of the around advices and replace + * the invocations to a wrapper call so that the around advice can further be inlined. + * <p/> + * This munger is used for @AJ aspects for which inlining wrapper is not done at compile time. + * <p/> + * 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. + * + * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a> + */ +public class BcelAccessForInlineMunger extends BcelTypeMunger { + + /** + * Wrapper member cache, key is wrapper name. + * This structure is queried when regular shadow matching in the advice body (call/get/set) occurs + */ + private Map m_inlineAccessorBcelMethods; + + /** + * The aspect we act for + */ + private LazyClassGen m_aspectGen; + + /** + * The wrapper method we need to add. Those are added at the end of the munging + */ + private Set m_inlineAccessorMethodGens; + + public BcelAccessForInlineMunger(ResolvedTypeX aspectType) { + super(null, aspectType); + } + + public boolean munge(BcelClassWeaver weaver) { + m_aspectGen = weaver.getLazyClassGen(); + m_inlineAccessorBcelMethods = new HashMap(0); + m_inlineAccessorMethodGens = new HashSet(); + + // look for all @Around advices + for (Iterator iterator = m_aspectGen.getMethodGens().iterator(); iterator.hasNext();) { + LazyMethodGen methodGen = (LazyMethodGen) iterator.next(); + if (methodGen.hasAnnotation(TypeX.forName("org/aspectj/lang/annotation/Around"))) { + openAroundAdvice(methodGen); + } + } + + // add the accessors + for (Iterator iterator = m_inlineAccessorMethodGens.iterator(); iterator.hasNext();) { + LazyMethodGen lazyMethodGen = (LazyMethodGen) iterator.next(); + m_aspectGen.addMethodGen(lazyMethodGen); + } + + // flush some + m_inlineAccessorMethodGens = null; + // we keep m_inlineAccessorsResolvedMembers for shadow matching + + return true; + } + + /** + * Looks in the wrapper we have added so that we can find their effective signature if needed + * + * @param member + * @return + */ + public ResolvedMember getMatchingSyntheticMember(Member member) { + return (ResolvedMember) m_inlineAccessorBcelMethods.get(member.getName()); + } + + public ResolvedMember getSignature() { + return null; + } + + /** + * Match only the aspect for which we act + * + * @param onType + * @return + */ + public boolean matches(ResolvedTypeX onType) { + return aspectType.equals(onType); + } + + /** + * Prepare the around advice, flag it as cannot be inlined if it can't be + * + * @param aroundAdvice + */ + private void openAroundAdvice(LazyMethodGen aroundAdvice) { + InstructionHandle curr = aroundAdvice.getBody().getStart(); + InstructionHandle end = aroundAdvice.getBody().getEnd(); + ConstantPoolGen cpg = aroundAdvice.getEnclosingClass().getConstantPoolGen(); + InstructionFactory factory = aroundAdvice.enclosingClass.getFactory(); + + boolean realizedCannotInline = false; + while (curr != end) { + if (realizedCannotInline) { + // we know we cannot inline this advice so no need for futher handling + break; + } + InstructionHandle next = curr.getNext(); + Instruction inst = curr.getInstruction(); + + // open-up method call + if ((inst instanceof InvokeInstruction)) { + InvokeInstruction invoke = (InvokeInstruction) inst; + ResolvedTypeX callee = m_aspectGen.getWorld().resolve(TypeX.forName(invoke.getClassName(cpg))); + + // look in the whole method list and not just declared for super calls and alike + List methods = callee.getMethodsWithoutIterator(); + for (Iterator iter = methods.iterator(); iter.hasNext();) { + BcelMethod resolvedMember = (BcelMethod) iter.next(); + if (invoke.getName(cpg).equals(resolvedMember.getName()) + && invoke.getSignature(cpg).equals(resolvedMember.getSignature()) + && !resolvedMember.isPublic()) { + if ("<init>".equals(invoke.getName(cpg))) { + // skipping open up for private constructor + // can occur when aspect new a private inner type + // too complex to handle new + dup + .. + invokespecial here. + aroundAdvice.setCanInline(false); + realizedCannotInline = true; + } else { + // specific handling for super.foo() calls, where foo is non public + if (aspectType.getSuperclass() != null + && aspectType.getSuperclass().getName().equals(callee.getName())) { + ResolvedMember accessor = createOrGetInlineAccessorForSuperDispatch(resolvedMember); + InvokeInstruction newInst = factory.createInvoke( + aspectType.getName(), + accessor.getName(), + BcelWorld.makeBcelType(accessor.getReturnType()), + BcelWorld.makeBcelTypes(accessor.getParameterTypes()), + Constants.INVOKEVIRTUAL + ); + curr.setInstruction(newInst); + } else { + ResolvedMember accessor = createOrGetInlineAccessorForMethod(resolvedMember); + InvokeInstruction newInst = factory.createInvoke( + aspectType.getName(), + accessor.getName(), + BcelWorld.makeBcelType(accessor.getReturnType()), + BcelWorld.makeBcelTypes(accessor.getParameterTypes()), + Constants.INVOKESTATIC + ); + curr.setInstruction(newInst); + } + } + + break;//ok we found a matching callee member and swapped the instruction with the accessor + } + } + } else if (inst instanceof FieldInstruction) { + FieldInstruction invoke = (FieldInstruction) inst; + ResolvedTypeX callee = m_aspectGen.getWorld().resolve(TypeX.forName(invoke.getClassName(cpg))); + for (int i = 0; i < callee.getDeclaredJavaFields().length; i++) { + ResolvedMember resolvedMember = callee.getDeclaredJavaFields()[i]; + if (invoke.getName(cpg).equals(resolvedMember.getName()) + && invoke.getSignature(cpg).equals(resolvedMember.getSignature()) + && !resolvedMember.isPublic()) { + final ResolvedMember accessor; + if ((inst instanceof GETFIELD) || (inst instanceof GETSTATIC)) { + accessor = createOrGetInlineAccessorForFieldGet(resolvedMember); + } else { + accessor = createOrGetInlineAccessorForFieldSet(resolvedMember); + } + InvokeInstruction newInst = factory.createInvoke( + aspectType.getName(), + accessor.getName(), + BcelWorld.makeBcelType(accessor.getReturnType()), + BcelWorld.makeBcelTypes(accessor.getParameterTypes()), + Constants.INVOKESTATIC + ); + curr.setInstruction(newInst); + + break;//ok we found a matching callee member and swapped the instruction with the accessor + } + } + } + + curr = next; + } + } + + /** + * Add an inline wrapper for a non public method call + * + * @param resolvedMember + * @return + */ + private ResolvedMember createOrGetInlineAccessorForMethod(ResolvedMember resolvedMember) { + String accessor = NameMangler.inlineAccessMethodForMethod( + resolvedMember.getName(), resolvedMember.getDeclaringType(), aspectType + ); + ResolvedMember inlineAccessor = (ResolvedMember) m_inlineAccessorBcelMethods.get(accessor); + if (inlineAccessor == null) { + // add static method to aspect + inlineAccessor = AjcMemberMaker.inlineAccessMethodForMethod( + aspectType, + resolvedMember + ); + + //add new accessor method to aspect bytecode + InstructionFactory factory = m_aspectGen.getFactory(); + LazyMethodGen method = makeMethodGen(m_aspectGen, inlineAccessor); + // flag it synthetic, AjSynthetic + method.makeSynthetic(); + method.addAttribute( + BcelAttributes.bcelAttribute(new AjAttribute.AjSynthetic(), m_aspectGen.getConstantPoolGen()) + ); + // flag the effective signature, so that we can deobfuscate the signature to apply method call pointcut + method.addAttribute( + BcelAttributes.bcelAttribute( + new AjAttribute.EffectiveSignatureAttribute(resolvedMember, Shadow.MethodCall, false), + m_aspectGen.getConstantPoolGen() + ) + ); + + m_inlineAccessorMethodGens.add(method); + + InstructionList il = method.getBody(); + int register = 0; + for (int i = 0; i < inlineAccessor.getParameterTypes().length; i++) { + TypeX typeX = inlineAccessor.getParameterTypes()[i]; + Type type = BcelWorld.makeBcelType(typeX); + il.append(InstructionFactory.createLoad(type, register)); + register += type.getSize(); + } + il.append( + Utility.createInvoke( + factory, + resolvedMember.isStatic() ? Constants.INVOKESTATIC : Constants.INVOKESPECIAL, + resolvedMember + ) + ); + il.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(inlineAccessor.getReturnType()))); + + m_inlineAccessorBcelMethods.put( + accessor, + new BcelMethod(m_aspectGen.getBcelObjectType(), method.getMethod()) + ); + } + return inlineAccessor; + } + + /** + * Add an inline wrapper for a non public super.method call + * + * @param resolvedMember + * @return + */ + private ResolvedMember createOrGetInlineAccessorForSuperDispatch(ResolvedMember resolvedMember) { + String accessor = NameMangler.superDispatchMethod( + aspectType, resolvedMember.getName() + ); + ResolvedMember inlineAccessor = (ResolvedMember) m_inlineAccessorBcelMethods.get(accessor); + if (inlineAccessor == null) { + // add static method to aspect + inlineAccessor = AjcMemberMaker.superAccessMethod( + aspectType, + resolvedMember + ); + + //add new accessor method to aspect bytecode + InstructionFactory factory = m_aspectGen.getFactory(); + LazyMethodGen method = makeMethodGen(m_aspectGen, inlineAccessor); + // flag it synthetic, AjSynthetic + method.makeSynthetic(); + method.addAttribute( + BcelAttributes.bcelAttribute(new AjAttribute.AjSynthetic(), m_aspectGen.getConstantPoolGen()) + ); + // flag the effective signature, so that we can deobfuscate the signature to apply method call pointcut + method.addAttribute( + BcelAttributes.bcelAttribute( + new AjAttribute.EffectiveSignatureAttribute(resolvedMember, Shadow.MethodCall, false), + m_aspectGen.getConstantPoolGen() + ) + ); + + m_inlineAccessorMethodGens.add(method); + + InstructionList il = method.getBody(); + il.append(InstructionConstants.ALOAD_0); + int register = 0; + for (int i = 0; i < inlineAccessor.getParameterTypes().length; i++) { + TypeX typeX = inlineAccessor.getParameterTypes()[i]; + Type type = BcelWorld.makeBcelType(typeX); + il.append(InstructionFactory.createLoad(type, register)); + register += type.getSize(); + } + il.append( + Utility.createInvoke( + factory, + Constants.INVOKESPECIAL, + resolvedMember + ) + ); + il.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(inlineAccessor.getReturnType()))); + + m_inlineAccessorBcelMethods.put( + accessor, + new BcelMethod(m_aspectGen.getBcelObjectType(), method.getMethod()) + ); + } + return inlineAccessor; + } + + /** + * Add an inline wrapper for a non public field get + * + * @param resolvedMember + * @return + */ + private ResolvedMember createOrGetInlineAccessorForFieldGet(ResolvedMember resolvedMember) { + String accessor = NameMangler.inlineAccessMethodForFieldGet( + resolvedMember.getName(), resolvedMember.getDeclaringType(), aspectType + ); + ResolvedMember inlineAccessor = (ResolvedMember) m_inlineAccessorBcelMethods.get(accessor); + if (inlineAccessor == null) { + // add static method to aspect + inlineAccessor = AjcMemberMaker.inlineAccessMethodForFieldGet( + aspectType, + resolvedMember + ); + + //add new accessor method to aspect bytecode + InstructionFactory factory = m_aspectGen.getFactory(); + LazyMethodGen method = makeMethodGen(m_aspectGen, inlineAccessor); + // flag it synthetic, AjSynthetic + method.makeSynthetic(); + method.addAttribute( + BcelAttributes.bcelAttribute(new AjAttribute.AjSynthetic(), m_aspectGen.getConstantPoolGen()) + ); + // flag the effective signature, so that we can deobfuscate the signature to apply method call pointcut + method.addAttribute( + BcelAttributes.bcelAttribute( + new AjAttribute.EffectiveSignatureAttribute(resolvedMember, Shadow.FieldGet, false), + m_aspectGen.getConstantPoolGen() + ) + ); + + m_inlineAccessorMethodGens.add(method); + + InstructionList il = method.getBody(); + if (resolvedMember.isStatic()) { + // field accessed is static so no "this" as accessor sole parameter + } else { + il.append(InstructionConstants.ALOAD_0); + } + il.append( + Utility.createGet( + factory, + resolvedMember + ) + ); + il.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(inlineAccessor.getReturnType()))); + + m_inlineAccessorBcelMethods.put( + accessor, + new BcelMethod(m_aspectGen.getBcelObjectType(), method.getMethod()) + ); + } + return inlineAccessor; + } + + /** + * Add an inline wrapper for a non public field set + * + * @param resolvedMember + * @return + */ + private ResolvedMember createOrGetInlineAccessorForFieldSet(ResolvedMember resolvedMember) { + String accessor = NameMangler.inlineAccessMethodForFieldSet( + resolvedMember.getName(), resolvedMember.getDeclaringType(), aspectType + ); + ResolvedMember inlineAccessor = (ResolvedMember) m_inlineAccessorBcelMethods.get(accessor); + if (inlineAccessor == null) { + // add static method to aspect + inlineAccessor = AjcMemberMaker.inlineAccessMethodForFieldSet( + aspectType, + resolvedMember + ); + + //add new accessor method to aspect bytecode + InstructionFactory factory = m_aspectGen.getFactory(); + LazyMethodGen method = makeMethodGen(m_aspectGen, inlineAccessor); + // flag it synthetic, AjSynthetic + method.makeSynthetic(); + method.addAttribute( + BcelAttributes.bcelAttribute(new AjAttribute.AjSynthetic(), m_aspectGen.getConstantPoolGen()) + ); + // flag the effective signature, so that we can deobfuscate the signature to apply method call pointcut + method.addAttribute( + BcelAttributes.bcelAttribute( + new AjAttribute.EffectiveSignatureAttribute(resolvedMember, Shadow.FieldSet, false), + m_aspectGen.getConstantPoolGen() + ) + ); + + m_inlineAccessorMethodGens.add(method); + + InstructionList il = method.getBody(); + if (resolvedMember.isStatic()) { + // field accessed is static so sole parameter is field value to be set + il.append(InstructionFactory.createLoad(BcelWorld.makeBcelType(resolvedMember.getReturnType()), 0)); + } else { + il.append(InstructionConstants.ALOAD_0); + il.append(InstructionFactory.createLoad(BcelWorld.makeBcelType(resolvedMember.getReturnType()), 1)); + } + il.append( + Utility.createSet( + factory, + resolvedMember + ) + ); + il.append(InstructionConstants.RETURN); + + m_inlineAccessorBcelMethods.put( + accessor, + new BcelMethod(m_aspectGen.getBcelObjectType(), method.getMethod()) + ); + } + return inlineAccessor; + } +} diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java b/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java index 16ac151db..fc5668c24 100644 --- a/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java +++ b/weaver/src/org/aspectj/weaver/bcel/BcelClassWeaver.java @@ -1505,7 +1505,7 @@ class BcelClassWeaver implements IClassWeaver { annotations = resolvedDooberry.getAnnotationTypes(); } } else if (rm.getKind()==Member.METHOD && !rm.isAbstract()) { - if (methodName.startsWith("ajc$inlineAccessMethod")) { + if (methodName.startsWith("ajc$inlineAccessMethod") || methodName.startsWith("ajc$superDispatch")) { ResolvedMember resolvedDooberry = world.resolve(declaredSig); annotations = resolvedDooberry.getAnnotationTypes(); } else { diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelPerClauseAspectAdder.java b/weaver/src/org/aspectj/weaver/bcel/BcelPerClauseAspectAdder.java index 254f429fe..c3b158179 100644 --- a/weaver/src/org/aspectj/weaver/bcel/BcelPerClauseAspectAdder.java +++ b/weaver/src/org/aspectj/weaver/bcel/BcelPerClauseAspectAdder.java @@ -119,25 +119,24 @@ public class BcelPerClauseAspectAdder extends BcelTypeMunger { generatePerTWGetInstanceMethod(gen); generatePerTWCreateAspectInstanceMethod(gen); } else { - throw new RuntimeException("TODO not yet implemented perClause " + kind.getName()); + throw new Error("should not happen - not such kind " + kind.getName()); } return true; } public ResolvedMember getMatchingSyntheticMember(Member member) { - //TODO is that ok ? return null; } public ResolvedMember getSignature() { - // TODO what to do here ? return null; - //throw new RuntimeException("not implemented - BcelPerClauseAspectAdder"); } public boolean matches(ResolvedTypeX onType) { - return true;//onType.equals(aspectType); + //we cannot return onType.equals(aspectType) + //since we need to eagerly create the nested ajcMighHaveAspect interface on LTW + return true; } private void generatePerClauseMembers(LazyClassGen classGen) { diff --git a/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java b/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java index f465bc2f1..5a62d9fc7 100644 --- a/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java +++ b/weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java @@ -1354,4 +1354,15 @@ public final class LazyMethodGen { public void setCanInline(boolean canInline) { this.canInline = canInline; } + + /** + * Adds an attribute to the method + * @param attr + */ + public void addAttribute(Attribute attr) { + Attribute[] newAttributes = new Attribute[attributes.length + 1]; + System.arraycopy(attributes, 0, newAttributes, 0, attributes.length); + newAttributes[attributes.length] = attr; + attributes = newAttributes; + } } diff --git a/weaver/src/org/aspectj/weaver/patterns/PerCflow.java b/weaver/src/org/aspectj/weaver/patterns/PerCflow.java index cded77643..3d647c455 100644 --- a/weaver/src/org/aspectj/weaver/patterns/PerCflow.java +++ b/weaver/src/org/aspectj/weaver/patterns/PerCflow.java @@ -34,6 +34,8 @@ import org.aspectj.weaver.Shadow; import org.aspectj.weaver.TypeX; import org.aspectj.weaver.VersionedDataInputStream; import org.aspectj.weaver.World; +import org.aspectj.weaver.bcel.BcelAccessForInlineMunger; +import org.aspectj.weaver.ataspectj.Ajc5MemberMaker; import org.aspectj.weaver.ast.Expr; import org.aspectj.weaver.ast.Test; @@ -103,6 +105,11 @@ public class PerCflow extends PerClause { ); } + //ATAJ inline around advice support + if (Ajc5MemberMaker.isAnnotationStyleAspect(inAspect)) { + inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect)); + } + return ret; } diff --git a/weaver/src/org/aspectj/weaver/patterns/PerObject.java b/weaver/src/org/aspectj/weaver/patterns/PerObject.java index 79426942e..2374b8e2c 100644 --- a/weaver/src/org/aspectj/weaver/patterns/PerObject.java +++ b/weaver/src/org/aspectj/weaver/patterns/PerObject.java @@ -29,6 +29,8 @@ import org.aspectj.weaver.ResolvedTypeX; import org.aspectj.weaver.Shadow; import org.aspectj.weaver.VersionedDataInputStream; import org.aspectj.weaver.World; +import org.aspectj.weaver.bcel.BcelAccessForInlineMunger; +import org.aspectj.weaver.ataspectj.Ajc5MemberMaker; import org.aspectj.weaver.ast.Expr; import org.aspectj.weaver.ast.Test; import org.aspectj.weaver.ast.Var; @@ -113,6 +115,11 @@ public class PerObject extends PerClause { ); } + //ATAJ inline around advice support + if (Ajc5MemberMaker.isAnnotationStyleAspect(inAspect)) { + inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect)); + } + return ret; } diff --git a/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java b/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java index f98d07980..7c053e98d 100644 --- a/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java +++ b/weaver/src/org/aspectj/weaver/patterns/PerSingleton.java @@ -23,6 +23,7 @@ import org.aspectj.weaver.ISourceContext; import org.aspectj.weaver.ResolvedTypeX; import org.aspectj.weaver.Shadow; import org.aspectj.weaver.VersionedDataInputStream; +import org.aspectj.weaver.bcel.BcelAccessForInlineMunger; import org.aspectj.weaver.ast.Expr; import org.aspectj.weaver.ast.Literal; import org.aspectj.weaver.ast.Test; @@ -104,6 +105,11 @@ public class PerSingleton extends PerClause { ); } + //ATAJ inline around advice support + if (Ajc5MemberMaker.isAnnotationStyleAspect(inAspect)) { + inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect)); + } + return ret; } diff --git a/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java b/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java index df2db0cbb..157f10223 100644 --- a/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java +++ b/weaver/src/org/aspectj/weaver/patterns/PerTypeWithin.java @@ -32,6 +32,8 @@ import org.aspectj.weaver.ResolvedTypeX; import org.aspectj.weaver.Shadow; import org.aspectj.weaver.VersionedDataInputStream; import org.aspectj.weaver.World; +import org.aspectj.weaver.bcel.BcelAccessForInlineMunger; +import org.aspectj.weaver.ataspectj.Ajc5MemberMaker; import org.aspectj.weaver.ast.Expr; import org.aspectj.weaver.ast.Literal; import org.aspectj.weaver.ast.Test; @@ -153,6 +155,11 @@ public class PerTypeWithin extends PerClause { ); } + //ATAJ inline around advice support + if (Ajc5MemberMaker.isAnnotationStyleAspect(inAspect)) { + inAspect.crosscuttingMembers.addTypeMunger(new BcelAccessForInlineMunger(inAspect)); + } + return ret; } |