[aspectj-users] private calls and within inner classes

[Bruno Harbulot <bruno.harbulot@xxxxxxxxxxxx>]

Hello,


I'm trying to intercept calls to private methods (Test.InnerA.runPrivate 
and Test.runPrivate) from within a method belonging to an inner class 
(Test.InnerB.InnerInnerB). The example is a bit complicated, but 
corresponds to some java code which is not mine and that I would like to 
advise.

It seems that "withincode" (matching within the code of 
Test.InnerB.InnerInnerB.run())  does not match calls to these private 
methods. It would have worked with ajc 1.0.6.
Also, surprisingly, it works with the equivalent public method, but the 
AJDT visualiser shows indicators (on Test.runPrivate and 
Test.runPrivateStatic) as if they were "execution" and not "call" pointcuts.
I've read the AspectJ 1.1 readme, but the changes to "call" and the 
limitations of "withincode" don't seem to explain the problems with this 
particular example.

Is there any way I could advise calls to InnerA.runPrivate(..) made from 
within InnerB.InnerInnerB.run() (and get hold of the instance of 
InnerInnerB)?


Thanks,

Bruno.







Here is the test code:


public class Test {
	public static class InnerA {
		private static void runPrivate(int a) {
			System.out.println("InnerA private: "+a) ;
		}
		public static void runPublic(int a) {
			System.out.println("InnerA public: "+a) ;
		}
	}
	
	private static void runPrivateStatic(int a) {
		System.out.println("runPrivateStatic: "+a) ;
	}
	
	public static void runPublicStatic(int a) {
		System.out.println("runPublicStatic: "+a) ;
	}
	
	private void runPrivate(int a) {
		System.out.println("runPrivate: "+a) ;
	}
	
	public static class InnerB {
		InnerInnerB innerinnerb = new InnerInnerB() ;
		public class InnerInnerB {			
			public void run() {
				InnerA.runPrivate(1) ;
				InnerA.runPublic(1) ;
				runPrivateStatic(1) ;
				runPublicStatic(1) ;
				Test t = new Test() ;
				t.runPrivate(1) ;
			}
		}
		
		public void run() {
			innerinnerb.run() ;
		}
	}
	
	public void run() {
		InnerA.runPrivate(2) ;
		InnerA.runPublic(2) ;
		runPrivateStatic(2) ;
		runPublicStatic(2) ;
		runPrivate(2) ;
	}

	public static void main(String[] args) {
		InnerB innerb = new InnerB() ;
		innerb.run() ;
		Test t = new Test() ;
		t.run() ;
	}
}



privileged aspect TestAspect {
	/* Does not match anything with ajc 1.1, but matches with ajc 1.0 */
	void around(Test.InnerB.InnerInnerB iib, int a): call(private void 
Test.InnerA.runPrivate(..)) && args(a) && this(iib) && withincode(* 
Test.InnerB.InnerInnerB.run()){
		proceed(iib, a + 10);
	}
	
	/* Does not match anything with ajc 1.1, but matches with ajc 1.0 */
	void around(Test.InnerB.InnerInnerB iib, int a): call(void 
Test.InnerA.runPrivate(..)) && args(a) && this(iib) && withincode(* 
Test.InnerB.InnerInnerB.run()){
		proceed(iib, a + 20);
	}
	
	/* Matches */
	void around(Test.InnerB.InnerInnerB iib, int a): call(void 
Test.InnerA.runPublic(..)) && args(a) && this(iib) && withincode(* 
Test.InnerB.InnerInnerB.run()){
		proceed(iib, a + 40);
	}

	/* Does not match anything with ajc 1.1, but matches with ajc 1.0 */
	void around(int a): call(private void Test.runPrivateStatic(..)) && 
args(a) && withincode(* Test.InnerB.InnerInnerB.run()){
		proceed(a + 100);
	}
	
	/* Matches */
	void around(int a): call(void Test.runPublicStatic(..)) && args(a) && 
withincode(* Test.InnerB.InnerInnerB.run()){
		proceed(a + 200);
	}
	
	/* Does not match anything with ajc 1.1, but matches with ajc 1.0 */
	void around(int a): call(void Test.runPrivate(..)) && args(a) && 
withincode(* Test.InnerB.InnerInnerB.run()){
		proceed(a + 400);
	}
	
	/* Matches */
	void around(int a): call(private void Test.runPrivateStatic(..)) && 
args(a){
		proceed(a + 1000);
	}
	
	/* Matches */
	void around(int a): call(void Test.runPublicStatic(..)) && args(a) {
		proceed(a + 2000);
	}
	
	/* Matches */
	void around(int a): call(void Test.runPrivate(..)) && args(a) {
		proceed(a + 4000);
	}
}






Here are the results with ajc 1.1 and a recent AJDT:

InnerA private: 1
InnerA public: 41
runPrivateStatic: 1001
runPublicStatic: 2201
runPrivate: 4001
InnerA private: 2
InnerA public: 2
runPrivateStatic: 1002
runPublicStatic: 2002
runPrivate: 4002





Here are the results with ajc 1.0.6:

InnerA private: 31
InnerA public: 41
runPrivateStatic: 1101
runPublicStatic: 2201
runPrivate: 4401
InnerA private: 2
InnerA public: 2
runPrivateStatic: 1002
runPublicStatic: 2002
runPrivate: 4002