[aspectj-dev] LTW, Declare parents and load order

[Simone Gianni <simoneg@xxxxxxxxxx>]

Hi all,
I noticed that, using LTW, there is a difference in how declare parents 
is applied depending on the load order. In many many cases, this can go 
completely unnoticed or be completely legal, but in some others it is 
not. In my case I'm using the experimental hasmethod, but probably it 
could happen also using other kind of type patterns.

The case is when I'm declaring a parent unless the superclasses already 
have that parent. If parent classes are loaded before subclasses, it 
works perfectly, otherwise it injects the interface/methods in the 
subclasses and later also on the superclasses. This IS valid Java by 
itself, but it is a problem when other frameworks (like JPA) use 
reflection to determine which methods or interfaces a certain class has, 
and they mandate that some of those methods must be present only on the 
topmost classes and not be overridden on subclasses.

I can see that AspectJ resolves also superclasses (maybe it does that 
only sometimes?) and weaves them in the meanwhile 
(GeneratedClassHandler.acceptClass should serve this purpose), so this 
should not theoretically happen, unless :
- Not all join points/patterns trigger superclass parsing
- It is dependent on the order of expressions in the pattern, for 
example if it first checks for the presence of the interface and then 
arrives to an expression requiring parsing of the superclass
- Parsing the parent does not take into account ITDs, the parent is not 
weaved or not completely, or something similar happens.

"declare parents" is inherently prone to this kind of errors, cause it 
is partially declarative and partially not. Think about "declare parents 
: org.something.model.* && !(MyTracingInterface+) : MyTracingInterface", 
it is declaratively speaking invalid, or could apply the interface here 
and there, or should trigger a weaving of all superclasses and apply it 
only to the topmost weavable classes. It seems like this is driven by 
load sequence, or by some other order dependent stuff.

I'm trying to create a test case to demonstrate the problem and 
understand better how it happens, but probably in the mean time you can 
point me in the right direction or stop me if you already know the answer :D

Simone

--
Simone Gianni            CEO Semeru s.r.l.           Apache Committer
http://www.simonegianni.it/