From b7929e91659708dc27141f587ad236af7bfa8287 Mon Sep 17 00:00:00 2001 From: acolyer Date: Tue, 13 Dec 2005 22:19:08 +0000 Subject: [PATCH] tests and fix for pr119749 --- tests/bugs150/pr119749.aj | 62 +++++++++++++++++++ .../ajdkExamples/AnnotationInheritance.aj | 2 +- .../systemtest/ajc150/Ajc150Tests.java | 4 ++ .../org/aspectj/systemtest/ajc150/ajc150.xml | 21 ++++++- .../weaver/patterns/SignaturePattern.java | 32 ++++++---- .../patterns/SignaturePatternTestCase.java | 6 +- 6 files changed, 109 insertions(+), 18 deletions(-) create mode 100644 tests/bugs150/pr119749.aj diff --git a/tests/bugs150/pr119749.aj b/tests/bugs150/pr119749.aj new file mode 100644 index 000000000..dc3cc4bb5 --- /dev/null +++ b/tests/bugs150/pr119749.aj @@ -0,0 +1,62 @@ + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.aspectj.lang.JoinPoint; + +public aspect pr119749 { + // not inherited + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.METHOD) + @interface Me{} + + static class C { + @Me() + void m() throws Exception {} + } + + static class D extends C{ + void m() {} + } + + static class E { + D d(){return null;} + C c(){return null;} + static aspect A { + declare warning: execution(C E.*()) : "C E.*()"; //L26 + declare warning: execution(D E.*()) : "D E.*()"; // L25 + } + } + + public static void main(String[] args) { + C c = new C(); + D d = new D(); + C cd = d; + try {c.m();} catch (Exception e) {} + try {cd.m();} catch (Exception e) {} + d.m(); + } + + static aspect A { + static void log(JoinPoint jp, Object o) { + System.out.println("" + jp + ": " + o); + } + pointcut scope() : within(pr119749); + pointcut execMe() :execution(@Me void m()) && scope(); // L17 + pointcut execEx() :execution(void m() throws Exception) && scope(); // L17 + pointcut execAnyEx() :execution(* *(..) throws Exception) && scope(); // L17 + pointcut callEx() :call(void m() throws Exception) && scope(); // L37,38 + declare warning : execMe() : "aa @Me void m()"; + declare warning : execEx() : "aa void m() throws Exception"; + declare warning : execAnyEx() : "aa * *(..) throws Exception"; + declare warning : callEx() : "aa call void m() throws Exception"; + before(Me me) : @annotation(me) && execMe() { + log(thisJoinPoint, "execMe[" + me + "]"); + } + before() : execEx() { + log(thisJoinPoint, "execEx"); + } + } +} \ No newline at end of file diff --git a/tests/java5/annotations/ajdkExamples/AnnotationInheritance.aj b/tests/java5/annotations/ajdkExamples/AnnotationInheritance.aj index 2ca13eba4..1a437183b 100644 --- a/tests/java5/annotations/ajdkExamples/AnnotationInheritance.aj +++ b/tests/java5/annotations/ajdkExamples/AnnotationInheritance.aj @@ -23,7 +23,7 @@ pointcut annotatedC2MethodCall() : call(@SomeAnnotation * C2.aMethod()); // matches nothing - pointcut annotatedMethodCall() : // CW L16, L17 + pointcut annotatedMethodCall() : // CW L16 call(@SomeAnnotation * aMethod()); declare warning : annotatedC2MethodCall() : "annotatedC2MethodCall()"; diff --git a/tests/src/org/aspectj/systemtest/ajc150/Ajc150Tests.java b/tests/src/org/aspectj/systemtest/ajc150/Ajc150Tests.java index d5c3c2bdc..bc7d7e683 100644 --- a/tests/src/org/aspectj/systemtest/ajc150/Ajc150Tests.java +++ b/tests/src/org/aspectj/systemtest/ajc150/Ajc150Tests.java @@ -847,6 +847,10 @@ public class Ajc150Tests extends org.aspectj.testing.XMLBasedAjcTestCase { runTest("reflection on @DeclareParents"); } + public void testModifierOverrides() { + runTest("modifier overrides"); + } + // helper methods..... public SyntheticRepository createRepos(File cpentry) { diff --git a/tests/src/org/aspectj/systemtest/ajc150/ajc150.xml b/tests/src/org/aspectj/systemtest/ajc150/ajc150.xml index 19bcb55a9..d6814e28e 100644 --- a/tests/src/org/aspectj/systemtest/ajc150/ajc150.xml +++ b/tests/src/org/aspectj/systemtest/ajc150/ajc150.xml @@ -6,6 +6,25 @@ + + + + + + + + + + + + + + + + + + + @@ -2683,7 +2702,7 @@ - + diff --git a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java index 3759d12d7..445cc53a1 100644 --- a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java +++ b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java @@ -305,24 +305,30 @@ public class SignaturePattern extends PatternNode { return FuzzyBoolean.MAYBE; } + // modifiers match on the *subject* if (!modifiers.matches(aMember.getModifiers())) { - if (aMember.isPrivate()) return FuzzyBoolean.NO; - else return FuzzyBoolean.MAYBE; + return FuzzyBoolean.NO; +// if (aMember.isPrivate()) return FuzzyBoolean.NO; +// else return FuzzyBoolean.MAYBE; + } + + // annotations match on the *subject* + if (!matchesAnnotations(aMember,inAWorld).alwaysTrue()) { + return FuzzyBoolean.NO; } - FuzzyBoolean matchesIgnoringAnnotations = FuzzyBoolean.YES; if (kind == Member.STATIC_INITIALIZATION) { - matchesIgnoringAnnotations = matchesExactlyStaticInitialization(aMember, inAWorld); + return matchesExactlyStaticInitialization(aMember, inAWorld); } else if (kind == Member.FIELD) { - matchesIgnoringAnnotations = matchesExactlyField(aMember,inAWorld); + return matchesExactlyField(aMember,inAWorld); } else if (kind == Member.METHOD) { - matchesIgnoringAnnotations = matchesExactlyMethod(aMember,inAWorld); + return matchesExactlyMethod(aMember,inAWorld); } else if (kind == Member.CONSTRUCTOR) { - matchesIgnoringAnnotations = matchesExactlyConstructor(aMember, inAWorld); + return matchesExactlyConstructor(aMember, inAWorld); + } else { + return FuzzyBoolean.YES; } - if (!matchesIgnoringAnnotations.alwaysTrue()) return matchesIgnoringAnnotations; - return matchesAnnotations(aMember, inAWorld); } /** @@ -357,6 +363,9 @@ public class SignaturePattern extends PatternNode { */ private FuzzyBoolean matchesExactlyMethod(JoinPointSignature aMethod, World world) { if (!name.matches(aMethod.getName())) return FuzzyBoolean.NO; + // Check the throws pattern + if (!throwsPattern.matches(aMethod.getExceptions(), world)) return FuzzyBoolean.NO; + if (!declaringType.matchesStatically(aMethod.getDeclaringType().resolve(world))) return FuzzyBoolean.MAYBE; if (!returnType.matchesStatically(aMethod.getReturnType().resolve(world))) { // looking bad, but there might be parameterization to consider... @@ -379,9 +388,6 @@ public class SignaturePattern extends PatternNode { // check that varargs specifications match if (!matchesVarArgs(aMethod,world)) return FuzzyBoolean.MAYBE; - // Check the throws pattern - if (!throwsPattern.matches(aMethod.getExceptions(), world)) return FuzzyBoolean.MAYBE; - // passed all the guards.. return FuzzyBoolean.YES; } @@ -477,7 +483,7 @@ public class SignaturePattern extends PatternNode { if (annotationPattern.matches(member).alwaysTrue()) { return FuzzyBoolean.YES; } else { - return FuzzyBoolean.MAYBE; // need to look at ancestor members too... + return FuzzyBoolean.NO; // do NOT look at ancestor members... } } diff --git a/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java b/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java index 935d3c262..40d345316 100644 --- a/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java +++ b/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java @@ -38,8 +38,8 @@ public class SignaturePatternTestCase extends TestCase { Member mOnDerived = MemberImpl.methodFromString("void fluffy.Derived.m()"); checkMatch(makeMethodPat("* fluffy.Base.*(..) throws java.lang.CloneNotSupportedException"), - new Member[] { mOnBase, mOnDerived }, - new Member[] { }); + new Member[] { mOnBase }, + new Member[] { mOnDerived }); checkMatch(makeMethodPat("* fluffy.Derived.*(..) throws java.lang.CloneNotSupportedException"), new Member[] { }, @@ -53,7 +53,7 @@ public class SignaturePatternTestCase extends TestCase { checkMatch(makeMethodPat("* *(..)"), M, NONE); checkMatch(makeMethodPat("* *(..) throws !*"), NO_EXCEPTIONS, M); - checkMatch(makeMethodPat("* *(..) throws *"), BOTH, NONE); + checkMatch(makeMethodPat("* *(..) throws *"), M, NO_EXCEPTIONS); checkMatch(makeMethodPat("* *(..) throws *, !*"), NONE, BOTH); checkMatch(makeMethodPat("* *(..) throws (!*)"), NONE, BOTH); -- 2.39.5