tests and fix for 136026: cflow verifyerror in non trivial combination of cflow pointcuts.

2 files changed, 140 insertions, 0 deletions

diff --git a/tests/bugs152/pr136026/CflowOrder.java b/tests/bugs152/pr136026/CflowOrder.java
new file mode 100644
index 000000000..a06fe518c
--- /dev/null
+++ b/tests/bugs152/pr136026/CflowOrder.java
@@ -0,0 +1,42 @@
+import java.io.PrintStream;
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME) @interface Marker {}
+
+class A {
+	@Marker void foo() { }
+    public static void main(String[] args) {
+        new A().foo();
+    }
+}
+
+public class CflowOrder {
+
+    public static void main(String[] args) {
+        A.main(null);
+    }
+
+    
+    
+    
+    static aspect MyAspect  {
+
+        pointcut annotated(Marker a) :  execution(@Marker * *(..)) && @annotation(a);
+
+        pointcut belowAnnotated() :         cflowbelow(annotated(Marker));
+        
+//        pointcut belowAnnotated() :         cflowbelow(execution(@Marker * *(..)) && @annotation(Marker));
+        
+      pointcut topAnnotated(Marker a) : annotated(a) && !belowAnnotated();
+
+      pointcut notTopAnnotated(/*Marker a,*/ Marker aTop) : 
+    	                                       /* annotated(a) &&*/ cflowbelow(annotated(aTop));
+      
+        // if this first, then no nonTopAnnotated advice
+        before(Marker a) : topAnnotated(a) { }
+        
+        // if topAnnotated is first, this does not run
+        before(Marker aTop) : notTopAnnotated( aTop) { }
+    }
+}
+
diff --git a/tests/bugs152/pr136026/CflowOrderOriginal.java b/tests/bugs152/pr136026/CflowOrderOriginal.java
new file mode 100644
index 000000000..bd3dea68f
--- /dev/null
+++ b/tests/bugs152/pr136026/CflowOrderOriginal.java
@@ -0,0 +1,98 @@
+package bugs;
+
+import java.io.PrintStream;
+import java.lang.annotation.*;
+
+import org.aspectj.lang.JoinPoint;
+
+public class CflowOrderOriginal {
+
+    public static void main(String[] args) {
+        Log.print("Starting CflowOrder.main(..)");
+        A.main(null);
+        Log.print("Ending CflowOrder.main(..)");
+    }
+
+    @Retention(value = RetentionPolicy.RUNTIME)
+    @interface Annotation {
+        String value();
+    }
+
+    static class A {
+        @Annotation("A.foo")
+        void foo() {
+            new B().foo();
+            Log.print("A.foo()");
+        }
+
+        public static void main(String[] args) {
+            new A().foo();
+            Log.print("A.main(..)");
+        }
+    }
+
+    static class B {
+        @Annotation("B.foo")
+        void foo() {
+            Log.print("B.foo()");
+        }
+    }
+
+    static class Log implements IAspect {
+        static final PrintStream out = System.err;
+
+        static void print(String label) {
+            out.println(label);
+        }
+
+        static void print(String label, JoinPoint tjp, JoinPoint.StaticPart sp,
+                Object a) {
+            out.println(label);
+//            out.println(" Join point: " + tjp);
+//            out.println(" Enclosing join point: " + sp);
+//            out.println(" Annotation: " + a);
+        }
+    }
+    static aspect Logger implements IAspect {
+
+        //declare error: execution(* *(..)) && !within(Log) : "er";
+
+//        before() : cflow(execution(void CflowOrder.main(String[]))) 
+//            && !call(* IAspect+.*(..)) && ! within(IAspect+) {
+//            Log.print("cflow(..main(..))", thisJoinPoint,
+//                    thisEnclosingJoinPointStaticPart, null);
+//        }
+    }
+
+    interface IAspect {}
+    static aspect MyAspect  implements IAspect {
+
+        pointcut annotated(Annotation a) :
+            call(@Annotation * *(..)) && @annotation(a);
+
+        pointcut belowAnnotated() :
+            cflowbelow(annotated(Annotation));
+      pointcut topAnnotated(Annotation a) : annotated(a) 
+            && !belowAnnotated();
+
+      pointcut notTopAnnotated(Annotation a, Annotation aTop) : annotated(a) 
+      && cflowbelow(annotated(aTop));
+//        pointcut topAnnotated(Annotation a) : annotated(a) 
+//            && !cflowbelow(annotated(Annotation));
+//
+//        pointcut notTopAnnotated(Annotation a, Annotation aTop) : annotated(a) 
+//            &&  cflowbelow(topAnnotated(aTop));
+
+        // if this first, then no nonTopAnnotated advice
+        before(Annotation a) : topAnnotated(a) {
+            Log.print("topAnnotated", thisJoinPoint,
+                    thisEnclosingJoinPointStaticPart, a);
+        }
+        // if topAnnotated is first, this does not run
+        before(Annotation a, Annotation aTop) : notTopAnnotated(a, aTop) {
+            Log.print("nonTopAnnotated", thisJoinPoint,
+                    thisEnclosingJoinPointStaticPart, a);
+        }
+    }
+}
+