removed erroneous "s" from method name

added extra utility method for warnings

update to expected messages for type pattern matching with generics

annotated lines that should produce compilation warnings

also support superinterfaces when converting an Eclipse TypeParameter into a TypeVariable

improved matching in canBeBoundTo to consider equality of all bounds when testing against a type variable reference

remember source location when faulting in generic type

changed the serialized form of a WildTypePattern to remember generic info... standby for mass updates of binary comparison tests.

fix #104212 very bad bug on static method call jp that has been around since java 1.4 is there

proper support for type variable across patterns in the Eclipse Source Type world. Still need serialization support for this.

new warnings for generics in patterns

change from isTypeVariable to isTypeVariableReference

more tests and refinement of existing tests

fixes bug in test case caught by improved error messages in compiler

dont go looking for generic types pre 1.5

generics:  fixes for decp testcases involving generic types targeted by parameterized decps.  Type variables now persist in the system for longer... also LazyClassGen generates correct generic signatures for modified types.

tidy up after a run...

fix in ltw log + test + some doc on custom message handler is evil

one more passing test...

wild type patterns with no type params ignore <...> when matching by name (raw match)

handle superinterfaces correctly for raw types

generics: testcase for decp'ing parameterized type onto a generic type that implements a parameterized type using a type variable type parameter ;)

commented out debug line...

ensure that when parameterizing a member, we handle any types that are themselves parameterized (eg. a return type List<N> should turn to List<String> when parameterized with String).

changes to construction and representation of parameterized types, and enforcement of the constraint that type mungers always operate on the generic type (never raw or parameterized)

organized imports - wanted to trigger a build :)

ltw reweavable test for Mattew bug, fix some wrong getCoreType that makes some stderr output when closure are encountered on ltw / dump

fix LTW for JMX stuff, rename messageHolder, some doc on that + dump

method name in weaver refactored.

More bits of fix for pr98901 (annotation copying)

@DeclareAnnotation and guard to not use it in M3, doc update for M3

First bits of fix for pr98901 (annotation copying)

testcases for pr98901 (annotations copied to targets of decannotation).  Not yet wired into the full 150 suite.

Fix for pr103266: allow for nulls in the visitor (can happen if there are syntax errors)

moves forGenericType from UnresolvedType to ResolvedType. Return value still needs changing... one step at a time!

makes fromBinding in EclipseFactory an instance rather than static method. This paves the way for fromBinding to return a ResolvedType (which needs the world that the instance contains) rather than an UnresolvedType.

This is the beginning of a significant refactoring needed to cleanly support generics. We need to be much crisper about when we have an unresolved type (plain old TypeX) and when we have a resolved type. This refactoring renames TypeX to UnresolvedType and ResolvedTypeX to ResolvedType. In addition, it moves a number of methods that were defined on TypeX but which can only be answered by resolved types down onto ResolvedType. At the moment, ResolvedType still extends UnresolvedType - but a ResolvedType is *not* a UnresolvedType and this inheritance of convenience will be broken down the line so that ResolvedType does not extend UnresolvedType. Full signature information can only be known for ResolvedTypes.

just comments (honest ;) ) describing the format of signatures for TypeXs.

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