organized imports

beginnings of support for matching against type variables

avoid losing type variable information when resolving bindings

now remembers its location for better error reporting

test case updates...

better error reporting when using type vars in inappropriate locations

added an additional message operation to tidy up weaver code

test for parameterized type usage

new message "a parameterized type pattern may not be used in a handler pointcut expression"

sometimes we get asked to resolve more than once, and that's ok...

more test cases covering generics in pointcut expressions

don't re-resolve already resolved types

teach a typex whether or not it represents a type variable

organized imports

Ant 1.6 antlib.xml support, per bug 103493

handles resolution of bindings when the pointcut uses type variables

a pointcut now has a simple list of type variable names in scope rather than a TypeVariableListPattern

test that a signature with a generic declaring type does not match on the erasure of the parameter types

organized imports

generics: new error messages.

I needed to make some changes to resolveBindings, but the original method had degenerated into such a mess that I've refactored it before continuing. This commit changes no functionality, it just makes the code more readable!

parameterized members remember their erasure and this is used in member matching so that a signature pattern based on the erasure of a signature can match parameterized member declarations.

test that a the erasure of a signature matches a parameterized implementation of a method

tests for Huff's fix for 102746 - not hooked up b/c harness manages classpath.

Variant of Huff's fix for 102746 - untested hypothesis

99861 temp fix for deadlock when Sun' Unsafe.defineClass API is used (deadlock in JVMTI obviously, not tied to AJ, but bothers Ron)

fix 83935 where Jp / Pjp is an arg and bound in a formal binding as well as another (or 2+) used as implicit bindings in @AJ

add unresolved TypeVariableRefTypes which are created by EclipseFactory during conversion of bindings to TypeX, and resolved to TypeVariableReferenceTypes by the world.

a simple type pattern for a generic type should match any parameterization of that type

added one simple test for matching members of a parameterized type.
Took me 3 days to get it to pass!!!

changed EclipseFactory.makeResolvedMember from static to non-static member and fully resolved all types involved.

generics: use raw type of iterator

generics: modified to use built in types since otherwise world setup is painful.

generics: temporarily use the raw type when matching until the type pattern logic is aware

generics: polices the combinations of decp when using generics/raws/parameterized types

generics: writes out correct class signature

generics: improved type resolution, aware of raw/simple/parameterized/generic

generics: dont assume bcelmethod, it cant be resolvedmember

generics: signature unpacking.

generics: dont assume its a bcelmethod.  When working with generic methods they are merely 'resolvedmembers'

generics: now promotes simple types to raw types if we discover they are generic during resolution.

generics: copes with '+' '-' in the signature, less than ideal...

generics: allow for type variables that arrive in static methods and don't come from the declaring type

generics: few bug fixes to ensure typex's know if they represent generics/raws or simples.

generics: lots of generic decp tests.

generics: ask for the appropriate TypeX depending on the binding

but i only changed a comment...

fixes dumb array cast

ability to replace upper bound (used when fixing up circular dependencies)

test case for Enum conversions

answer correct superclass and superinterfaces taking into account generic signature

handle recursive type variables such as Enum

beginnings of proper type variable support in Eclipse type world

do the right thing with ":" in an ftp

generics: includes fix for generic signatures

expose generic ClassTypeSignature for member resolving

support for unpacking generic signature

avoid needless resolving

improved tolerance for generics signature chars

simplify signature processing and remove implicit extends

added getTypeVariables to interface

give back parameterized versions of members for parameterized types

change signature until we figure out the right thing to do in TypeX

raise inner type visibility for subclasses

moved some tests with 1.5 dependencies

dummy implementation of getTypeVariables

added test for broken primitive case

fix in GenericSigParser when tokenising primitives

generics: more accurate generic type test.

generics: can determine if java class is generic.

create a typeX from a set of TypeX parameters

some /. confusion cleared up

small signature change in JavaClass

test cases for generics updates made by amc

include new test suites for generics updates

support for generics and type variables

proper implementation of canBeParameterized

utility class that converts from Bcel signature world to TypeX world

added support for canBeParameterized

can create a parameterized type from an array of TypeX's

supports isGeneric

TypeX hierarchy members for bounded reference types and type variables

simple implementation of isGeneric

copyright statement

lazy loading and parsing of generic signature

generics: new message

generics: decp tests, binary weaving

generics: decp tests

organized imports

temp removal of the call to build runtime with 11 javac.  WILL NEED TO FIX RUNTIME before finishing 1.5.0

add offset in MethodDeclarationAttribute for @AJ in AJDT

On the build machine, code to test is in jars, not in 'bin' folders - so the aj.path for the LTW tests needs to have an entry for asm.jar in addition to the asm/bin it currently has.  Otherwise they fail with 'NoClassDefFoundError: org/aspectj/asm/IRelationship$Kind'

generics: promoted getGenericType up to ResolvedTypeX - it will throw an exception if you ask a type that is not parameterized or raw

generics:  First simple change to ensure the pattern I<String> results in an ExactTypePattern that remembers the parameterization.

generics: one fix to ensure the class we output says 'class X implement I' rather than 'class X implements I<String>' when the I<String> is added via declare parents.  (I<String> should be captured in the signature attribute on the class X).  Also some placeholder code added (commented out) that we'll need when trying to fix up the signature attribute when binary weaving.

generics: implementation of getDeclaredGenericSignature()

generics: loads of changes to make the resolution process generics aware

generics: TypeXs are much more aware of generics.  The only method in this class not finished now is forGenericTypeSignature() - it does not quite capture all the information from the parsed generic signature in the TypeX it creates.  It currently captures enough for the testcases I've written - no doubt will need extending for other testcases.

nasty clone method fix for 83311

generics: