Description Wes Isberg 2006-04-10 21:41:44 EDT

While following up a mailing list question, I blundered into a bug I don't understand.  Same result in 1.5.1 (command-line) and 1.5.1a (via AJDT 1.3.1).  

---------------- output
Starting CflowOrder.main(..)
Exception in thread "main" java.lang.VerifyError: (class: bugs/CflowOrder$A, method: foo signature: ()V) Incompatible object argument for function call
	at bugs.CflowOrder.main(CflowOrder.java:20)

---------------- bugs/CflowOrder.java

package bugs;

import java.io.PrintStream;
import java.lang.annotation.*;

import org.aspectj.lang.JoinPoint;

public class CflowOrder {

    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("\tJoin point: " + tjp);
            out.println("\tEnclosing join point: " + sp);
            out.println("\tAnnotation: " + 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);
        }
    }
}