320358: type signature changes

15 files changed, 334 insertions, 210 deletions

diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/AjcMemberMaker.java b/org.aspectj.matcher/src/org/aspectj/weaver/AjcMemberMaker.java
index 1e533918d..918572bcd 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/AjcMemberMaker.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/AjcMemberMaker.java
@@ -109,7 +109,7 @@ public class AjcMemberMaker {
 		if (!isSerializableAspect(aspectType)) {
 			modifiers |= Modifier.TRANSIENT;
 		}
-		return new ResolvedMemberImpl(Member.FIELD, declaringType, modifiers, UnresolvedType.JAVA_LANG_STRING,
+		return new ResolvedMemberImpl(Member.FIELD, declaringType, modifiers, UnresolvedType.JL_STRING,
 				NameMangler.PERTYPEWITHIN_WITHINTYPEFIELD, UnresolvedType.NONE);
 	}
 
@@ -126,7 +126,7 @@ public class AjcMemberMaker {
 	public static ResolvedMember perTypeWithinGetInstance(UnresolvedType declaringType) {
 		// private static a.X ajc$getInstance(java.lang.Class)
 		ResolvedMemberImpl rm = new ResolvedMemberImpl(Member.METHOD, declaringType, PRIVATE_STATIC, declaringType, // return value
-				NameMangler.PERTYPEWITHIN_GETINSTANCE_METHOD, new UnresolvedType[] { UnresolvedType.JAVA_LANG_CLASS });
+				NameMangler.PERTYPEWITHIN_GETINSTANCE_METHOD, new UnresolvedType[] { UnresolvedType.JL_CLASS });
 		return rm;
 	}
 
@@ -134,7 +134,7 @@ public class AjcMemberMaker {
 	public static ResolvedMember perTypeWithinGetWithinTypeNameMethod(UnresolvedType declaringType, boolean inJava5Mode) {
 		// public String getWithinTypeName()
 		ResolvedMemberImpl rm = new ResolvedMemberImpl(Member.METHOD, declaringType, Modifier.PUBLIC,
-				UnresolvedType.JAVA_LANG_STRING, // return value
+				UnresolvedType.JL_STRING, // return value
 				NameMangler.PERTYPEWITHIN_GETWITHINTYPENAME_METHOD, UnresolvedType.NONE);
 		return rm;
 	}
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/ConcreteTypeMunger.java b/org.aspectj.matcher/src/org/aspectj/weaver/ConcreteTypeMunger.java
index a51de77c9..8f8687622 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/ConcreteTypeMunger.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/ConcreteTypeMunger.java
@@ -69,14 +69,16 @@ public abstract class ConcreteTypeMunger implements PartialOrder.PartialComparab
 	}
 
 	public ISourceLocation getSourceLocation() {
-		if (munger == null)
+		if (munger == null) {
 			return null;
+		}
 		return munger.getSourceLocation(); // XXX
 	}
 
 	public boolean matches(ResolvedType onType) {
-		if (munger == null)
+		if (munger == null) {
 			throw new RuntimeException("huh: " + this);
+		}
 		return munger.matches(onType, aspectType);
 	}
 
@@ -119,8 +121,9 @@ public abstract class ConcreteTypeMunger implements PartialOrder.PartialComparab
 	 * </code>
 	 */
 	public boolean isTargetTypeParameterized() {
-		if (munger == null)
+		if (munger == null) {
 			return false;
+		}
 		return munger.sharesTypeVariablesWithGenericType();
 	}
 
@@ -131,12 +134,13 @@ public abstract class ConcreteTypeMunger implements PartialOrder.PartialComparab
 	public abstract ConcreteTypeMunger parameterizedFor(ResolvedType targetType);
 
 	public boolean isLateMunger() {
-		if (munger == null)
+		if (munger == null) {
 			return false;
+		}
 		return munger.isLateMunger();
 	}
 
-	public abstract ConcreteTypeMunger parameterizeWith(Map parameterizationMap, World world);
+	public abstract ConcreteTypeMunger parameterizeWith(Map<String, UnresolvedType> parameterizationMap, World world);
 
 	/**
 	 * Some type mungers are created purely to help with the implementation of shadow mungers. For example to support the cflow()
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/MemberImpl.java b/org.aspectj.matcher/src/org/aspectj/weaver/MemberImpl.java
index 64ae458d2..fda448d5e 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/MemberImpl.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/MemberImpl.java
@@ -381,17 +381,13 @@ public class MemberImpl implements Member {
 	}
 
 	public String getParameterSignature() {
-		if (paramSignature != null) {
-			return paramSignature;
-		}
-		StringBuffer sb = new StringBuffer();
-		sb.append("(");
-		for (int i = 0; i < parameterTypes.length; i++) {
-			UnresolvedType tx = parameterTypes[i];
-			sb.append(tx.getSignature());
+		if (paramSignature == null) {
+			StringBuilder sb = new StringBuilder("(");
+			for (UnresolvedType parameterType : parameterTypes) {
+				sb.append(parameterType.getSignature());
+			}
+			paramSignature = sb.append(")").toString();
 		}
-		sb.append(")");
-		paramSignature = sb.toString();
 		return paramSignature;
 	}
 
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/MemberUtils.java b/org.aspectj.matcher/src/org/aspectj/weaver/MemberUtils.java
new file mode 100644
index 000000000..201eb758f
--- /dev/null
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/MemberUtils.java
@@ -0,0 +1,25 @@
+/* *******************************************************************
+ * Copyright (c) 2010 Contributors
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ * Andy Clement, SpringSource
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+/**
+ * Common utility methods for members.
+ * 
+ * @author Andy Clement
+ */
+public class MemberUtils {
+
+	public static boolean isConstructor(ResolvedMember member) {
+		return member.getName().equals("<init>");
+	}
+
+}
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/NewFieldTypeMunger.java b/org.aspectj.matcher/src/org/aspectj/weaver/NewFieldTypeMunger.java
index bb2cacbb1..ed8afc1e0 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/NewFieldTypeMunger.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/NewFieldTypeMunger.java
@@ -128,7 +128,7 @@ public class NewFieldTypeMunger extends ResolvedTypeMunger {
 		return nftm;
 	}
 
-	public ResolvedTypeMunger parameterizeWith(Map m, World w) {
+	public ResolvedTypeMunger parameterizeWith(Map<String, UnresolvedType> m, World w) {
 		ResolvedMember parameterizedSignature = getSignature().parameterizedWith(m, w);
 		NewFieldTypeMunger nftm = new NewFieldTypeMunger(parameterizedSignature, getSuperMethodsCalled(), typeVariableAliases);
 		nftm.setDeclaredSignature(getSignature());
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/NewMethodTypeMunger.java b/org.aspectj.matcher/src/org/aspectj/weaver/NewMethodTypeMunger.java
index da5c3b1f4..a6e0ffce7 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/NewMethodTypeMunger.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/NewMethodTypeMunger.java
@@ -69,9 +69,9 @@ public class NewMethodTypeMunger extends ResolvedTypeMunger {
 	public static ResolvedTypeMunger readMethod(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		ISourceLocation sloc = null;
 		ResolvedMemberImpl rmImpl = ResolvedMemberImpl.readResolvedMember(s, context);
-		Set superMethodsCalled = readSuperMethodsCalled(s);
+		Set<ResolvedMember> superMethodsCalled = readSuperMethodsCalled(s);
 		sloc = readSourceLocation(s);
-		List typeVarAliases = readInTypeAliases(s);
+		List<String> typeVarAliases = readInTypeAliases(s);
 
 		ResolvedTypeMunger munger = new NewMethodTypeMunger(rmImpl, superMethodsCalled, typeVarAliases);
 		if (sloc != null) {
@@ -138,7 +138,7 @@ public class NewMethodTypeMunger extends ResolvedTypeMunger {
 		return result;
 	}
 
-	public ResolvedTypeMunger parameterizeWith(Map m, World w) {
+	public ResolvedTypeMunger parameterizeWith(Map<String, UnresolvedType> m, World w) {
 		ResolvedMember parameterizedSignature = getSignature().parameterizedWith(m, w);
 		NewMethodTypeMunger nmtm = new NewMethodTypeMunger(parameterizedSignature, getSuperMethodsCalled(), typeVariableAliases);
 		nmtm.setDeclaredSignature(getSignature());
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedMemberImpl.java b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedMemberImpl.java
index 963490118..749a9bbff 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedMemberImpl.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedMemberImpl.java
@@ -1039,17 +1039,13 @@ public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, Anno
 	 * getParam
 	 */
 	public String getParameterSignatureErased() {
-		if (myParameterSignatureErasure != null) {
-			return myParameterSignatureErasure;
-		}
-		StringBuffer sig = new StringBuffer();
-		UnresolvedType[] myParameterTypes = getParameterTypes();
-		for (int i = 0; i < myParameterTypes.length; i++) {
-			UnresolvedType thisParameter = myParameterTypes[i];
-			// type vars will be erased to first bound
-			sig.append(thisParameter.getErasureSignature());
+		if (myParameterSignatureErasure == null) {
+			StringBuilder sig = new StringBuilder();
+			for (UnresolvedType parameter : getParameterTypes()) {
+				sig.append(parameter.getErasureSignature());
+			}
+			myParameterSignatureErasure = sig.toString();
 		}
-		myParameterSignatureErasure = sig.toString();
 		return myParameterSignatureErasure;
 	}
 
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedType.java b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedType.java
index 0bdb6953e..b500076e8 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedType.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedType.java
@@ -2499,7 +2499,7 @@ public abstract class ResolvedType extends UnresolvedType implements AnnotatedEl
 	 * @return true if assignable to java.lang.Exception
 	 */
 	public boolean isException() {
-		return (world.getCoreType(UnresolvedType.JAVA_LANG_EXCEPTION).isAssignableFrom(this));
+		return (world.getCoreType(UnresolvedType.JL_EXCEPTION).isAssignableFrom(this));
 	}
 
 	/**
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedTypeMunger.java b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedTypeMunger.java
index e08fe2f2e..2ba3cbc36 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedTypeMunger.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/ResolvedTypeMunger.java
@@ -488,7 +488,7 @@ public abstract class ResolvedTypeMunger {
 		return false;
 	}
 
-	public ResolvedTypeMunger parameterizeWith(Map m, World w) {
+	public ResolvedTypeMunger parameterizeWith(Map<String, UnresolvedType> m, World w) {
 		throw new BCException("Dont call parameterizeWith() on a type munger of this kind: " + this.getClass());
 	}
 
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java b/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java
index 7cdbe230b..c81e23133 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java
@@ -69,7 +69,7 @@ public class TypeFactory {
 	 * Creates a sensible unresolvedtype from some signature, for example: signature = LIGuard<TT;>; bound = toString=IGuard<T>
 	 * sig=PIGuard<TT;>; sigErasure=LIGuard; kind=parameterized
 	 */
-	private static UnresolvedType convertSigToType(String aSignature) {
+	static UnresolvedType convertSigToType(String aSignature) {
 		UnresolvedType bound = null;
 		int startOfParams = aSignature.indexOf('<');
 		if (startOfParams == -1) {
@@ -132,6 +132,15 @@ public class TypeFactory {
 					endOfParams = locateMatchingEndAngleBracket(lastType, startOfParams);
 					typeParams = createTypeParams(lastType.substring(startOfParams + 1, endOfParams));
 				}
+				StringBuilder s = new StringBuilder();
+				int firstAngleBracket = signature.indexOf('<');
+				s.append("P").append(signature.substring(1, firstAngleBracket));
+				s.append('<');
+				for (UnresolvedType typeParameter : typeParams) {
+					s.append(typeParameter.getSignature());
+				}
+				s.append(">;");
+				signature = s.toString();//'P' + signature.substring(1);
 				return new UnresolvedType(signature, signatureErasure, typeParams);
 			}
 			// can't replace above with convertSigToType - leads to stackoverflow
@@ -185,6 +194,54 @@ public class TypeFactory {
 		} else if (firstChar == '@') {
 			// missing type
 			return ResolvedType.MISSING;
+		} else if (firstChar == 'L') {
+			// only an issue if there is also an angle bracket
+			int leftAngleBracket = signature.indexOf('<');
+
+			if (leftAngleBracket == -1) {
+				return new UnresolvedType(signature);
+			} else {
+				int endOfParams = locateMatchingEndAngleBracket(signature, leftAngleBracket);
+				StringBuffer erasureSig = new StringBuffer(signature);
+				erasureSig.setCharAt(0, 'L');
+				while (leftAngleBracket != -1) {
+					erasureSig.delete(leftAngleBracket, endOfParams + 1);
+					leftAngleBracket = locateFirstBracket(erasureSig);
+					if (leftAngleBracket != -1) {
+						endOfParams = locateMatchingEndAngleBracket(erasureSig, leftAngleBracket);
+					}
+				}
+
+				String signatureErasure = erasureSig.toString();
+
+				// TODO should consider all the intermediate parameterizations as well!
+				// the type parameters of interest are only those that apply to the 'last type' in the signature
+				// if the signature is 'PMyInterface<String>$MyOtherType;' then there are none...
+				String lastType = null;
+				int nestedTypePosition = signature.indexOf("$", endOfParams); // don't look for $ INSIDE the parameters
+				if (nestedTypePosition != -1) {
+					lastType = signature.substring(nestedTypePosition + 1);
+				} else {
+					lastType = new String(signature);
+				}
+				leftAngleBracket = lastType.indexOf("<");
+				UnresolvedType[] typeParams = UnresolvedType.NONE;
+				if (leftAngleBracket != -1) {
+					endOfParams = locateMatchingEndAngleBracket(lastType, leftAngleBracket);
+					typeParams = createTypeParams(lastType.substring(leftAngleBracket + 1, endOfParams));
+				}
+				StringBuilder s = new StringBuilder();
+				int firstAngleBracket = signature.indexOf('<');
+				s.append("P").append(signature.substring(1, firstAngleBracket));
+				s.append('<');
+				for (UnresolvedType typeParameter : typeParams) {
+					s.append(typeParameter.getSignature());
+				}
+				s.append(">;");
+				signature = s.toString();//'P' + signature.substring(1);
+				return new UnresolvedType(signature, signatureErasure, typeParams);
+			}
+
 		}
 		return new UnresolvedType(signature);
 	}
@@ -224,16 +281,18 @@ public class TypeFactory {
 
 	private static UnresolvedType[] createTypeParams(String typeParameterSpecification) {
 		String remainingToProcess = typeParameterSpecification;
-		List types = new ArrayList();
+		List<UnresolvedType> types = new ArrayList<UnresolvedType>();
 		while (remainingToProcess.length() != 0) {
 			int endOfSig = 0;
 			int anglies = 0;
+			boolean hadAnglies = false;
 			boolean sigFound = false; // OPTIMIZE can this be done better?
 			for (endOfSig = 0; (endOfSig < remainingToProcess.length()) && !sigFound; endOfSig++) {
 				char thisChar = remainingToProcess.charAt(endOfSig);
 				switch (thisChar) {
 				case '<':
 					anglies++;
+					hadAnglies = true;
 					break;
 				case '>':
 					anglies--;
@@ -260,7 +319,11 @@ public class TypeFactory {
 					}
 				}
 			}
-			types.add(createTypeFromSignature(remainingToProcess.substring(0, endOfSig)));
+			String forProcessing = remainingToProcess.substring(0, endOfSig);
+			if (hadAnglies && forProcessing.charAt(0) == 'L') {
+				forProcessing = "P" + forProcessing.substring(1);
+			}
+			types.add(createTypeFromSignature(forProcessing));
 			remainingToProcess = remainingToProcess.substring(endOfSig);
 		}
 		UnresolvedType[] typeParams = new UnresolvedType[types.size()];
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedType.java b/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedType.java
index 992e38548..1193eff17 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedType.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedType.java
@@ -19,66 +19,22 @@ import java.io.IOException;
 import java.util.Map;
 
 import org.aspectj.util.GenericSignature;
-import org.aspectj.util.GenericSignature.ClassSignature;
 import org.aspectj.util.GenericSignatureParser;
+import org.aspectj.util.GenericSignature.ClassSignature;
 import org.aspectj.weaver.tools.Traceable;
 
 /**
- * A UnresolvedType represents a type to the weaver. It has a basic signature that knows nothing about type variables, type
- * parameters, etc.. UnresolvedTypes are resolved in some World (a repository of types). When a UnresolvedType is resolved it turns
- * into a ResolvedType which may be a primitive type, or a ReferenceType. ReferenceTypes may refer to simple, generic, parameterized
- * or type-variable based reference types. A ReferenceType is backed by a delegate that provides information about the type based on
- * some repository (currently either BCEL or an EclipseSourceType, but in the future we probably need to support java.lang.reflect
- * based delegates too).
- * 
+ * A UnresolvedType represents a type to the weaver. UnresolvedTypes are resolved in some World (a type repository). When a
+ * UnresolvedType is resolved it turns into a ResolvedType which may be a primitive type, or a ReferenceType. ReferenceTypes may
+ * refer to simple, generic, parameterized or type-variable based reference types. A ReferenceType is backed by a delegate that
+ * provides information about the type based on some repository (for example an Eclipse based delegate, a bytecode based delegate or
+ * a reflection based delegate).
+ * <p>
  * Every UnresolvedType has a signature, the unique key for the type in the world.
- * 
- * 
- * TypeXs are fully aware of their complete type information (there is no erasure in the UnresolvedType world). To achieve this, the
- * signature of TypeXs combines the basic Java signature and the generic signature information into one complete signature.
- * 
- * The format of a UnresolvedType signature is as follows:
- * 
- * a simple (non-generic, non-parameterized) type has the as its signature the Java signature. e.g. Ljava/lang/String;
- * 
- * a generic type has signature: TypeParamsOpt ClassSig SuperClassSig SuperIntfListOpt
- * 
- * following the Generic signature grammar in the JVM spec., but with the addition of the ClassSignature (which is not in the
- * generic signature). In addition type variable names are replaced by a simple number which represents their declaration order in
- * the type declaration.
- * 
- * e.g. public class Foo<T extends Number> would have signature: <1:Ljava/lang/Number>Lorg.xyz.Foo;Ljava/lang/Object;
- * 
- * A parameterized type is a distinct type in the world with its own signature following the grammar:
- * 
- * TypeParamsOpt ClassSig<ParamSigList>;
- * 
- * but with the L for the class sig replaced by "P". For example List<String> has signature
- * 
- * Pjava/util/List<Ljava/lang/String>;
- * 
- * and List<T> in the following class : class Foo<T> { List<T> lt; }
- * 
- * has signature: <1:>Pjava/util/List<T1;>;
- * 
- * A typex that represents a type variable has its own unique signature, following the grammar for a FormalTypeParameter in the JVM
- * spec.
- * 
- * A generic typex has its true signature and also an erasure signature. Both of these are keys pointing to the same UnresolvedType
- * in the world. For example List has signature:
- * 
- * <1:>Ljava/util/List;Ljava/lang/Object;
- * 
- * and the erasure signature
- * 
- * Ljava/util/List;
- * 
- * Generics wildcards introduce their own special signatures for type parameters. The wildcard ? has signature * The wildcard ?
- * extends Foo has signature +LFoo; The wildcard ? super Foo has signature -LFoo;
  */
 public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 
-	// common types referred to by the weaver
+	// common type structures
 	public static final UnresolvedType[] NONE = new UnresolvedType[0];
 	public static final UnresolvedType OBJECT = forSignature("Ljava/lang/Object;");
 	public static final UnresolvedType OBJECTARRAY = forSignature("[Ljava/lang/Object;");
@@ -91,10 +47,10 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	public static final UnresolvedType AT_RETENTION = forSignature("Ljava/lang/annotation/Retention;");
 	public static final UnresolvedType ENUM = forSignature("Ljava/lang/Enum;");
 	public static final UnresolvedType ANNOTATION = forSignature("Ljava/lang/annotation/Annotation;");
-	public static final UnresolvedType JAVA_LANG_CLASS = forSignature("Ljava/lang/Class;");
+	public static final UnresolvedType JL_CLASS = forSignature("Ljava/lang/Class;");
 	public static final UnresolvedType JAVA_LANG_CLASS_ARRAY = forSignature("[Ljava/lang/Class;");
-	public static final UnresolvedType JAVA_LANG_STRING = forSignature("Ljava/lang/String;");
-	public static final UnresolvedType JAVA_LANG_EXCEPTION = forSignature("Ljava/lang/Exception;");
+	public static final UnresolvedType JL_STRING = forSignature("Ljava/lang/String;");
+	public static final UnresolvedType JL_EXCEPTION = forSignature("Ljava/lang/Exception;");
 	public static final UnresolvedType JAVA_LANG_REFLECT_METHOD = forSignature("Ljava/lang/reflect/Method;");
 	public static final UnresolvedType JAVA_LANG_REFLECT_FIELD = forSignature("Ljava/lang/reflect/Field;");
 	public static final UnresolvedType JAVA_LANG_REFLECT_CONSTRUCTOR = forSignature("Ljava/lang/reflect/Constructor;");
@@ -106,18 +62,20 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	public static final UnresolvedType JOINPOINT_STATICPART = forSignature("Lorg/aspectj/lang/JoinPoint$StaticPart;");
 	public static final UnresolvedType JOINPOINT_ENCLOSINGSTATICPART = forSignature("Lorg/aspectj/lang/JoinPoint$EnclosingStaticPart;");
 
-	// this doesn't belong here and will get moved to ResolvedType later in the refactoring
+	// A type is considered missing if we have a signature for it but cannot find the delegate
 	public static final String MISSING_NAME = "@missing@";
 
 	// OPTIMIZE I dont think you can ask something unresolved what kind of type it is, how can it always know? Push down into
-	// resolvedtype
-	// that will force references to resolvedtypes to be correct rather than relying on unresolvedtypes to answer questions
+	// resolvedtype that will force references to resolvedtypes to be correct rather than relying on unresolvedtypes to answer questions
 	protected TypeKind typeKind = TypeKind.SIMPLE; // what kind of type am I?
 
+	protected String signature;
+
 	/**
-	 * THE SIGNATURE - see the comments above for how this is defined
+	 * The erasure of the signature. Contains only the Java signature of the type with all supertype, superinterface, type variable,
+	 * and parameter information removed.
 	 */
-	protected String signature;
+	protected String signatureErasure;
 
 	/**
 	 * Calculated on first request - the package name (java.lang for type java.lang.String)
@@ -130,12 +88,6 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	private String className;
 
 	/**
-	 * The erasure of the signature. Contains only the Java signature of the type with all supertype, superinterface, type variable,
-	 * and parameter information removed.
-	 */
-	protected String signatureErasure;
-
-	/**
 	 * Iff isParameterized(), then these are the type parameters
 	 */
 	protected UnresolvedType[] typeParameters;
@@ -198,7 +150,7 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	}
 
 	/**
-	 * Equality is checked based on the underlying signature. {@link ResolvedType} objects' equals is by reference.
+	 * Equality is checked based on the underlying signature.
 	 */
 	@Override
 	public boolean equals(Object other) {
@@ -237,7 +189,7 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 		}
 	}
 
-	// ---- Things we can do without a world
+	// The operations supported by an UnresolvedType are those that do not require a world
 
 	/**
 	 * This is the size of this type as used in JVM.
@@ -246,15 +198,6 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 		return 1;
 	}
 
-	public static UnresolvedType makeArray(UnresolvedType base, int dims) {
-		StringBuffer sig = new StringBuffer();
-		for (int i = 0; i < dims; i++) {
-			sig.append("[");
-		}
-		sig.append(base.getSignature());
-		return UnresolvedType.forSignature(sig.toString());
-	}
-
 	/**
 	 * NOTE: Use forSignature() if you can, it'll be cheaper ! Constructs a UnresolvedType for a java language type name. For
 	 * example:
@@ -398,7 +341,7 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	 * 
 	 * </blockquote>
 	 * 
-	 * Types may equivalently be produced by this or by {@link #forName(String)}.
+	 * Types may equivalently be produced by this or by {@link #forName(String)}. This method should not be passed P signatures.
 	 * 
 	 * <blockquote>
 	 * 
@@ -413,6 +356,7 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	 * @return a type object represnting that JVM bytecode signature.
 	 */
 	public static UnresolvedType forSignature(String signature) {
+		assert !(signature.startsWith("L") && signature.indexOf("<") != -1);
 		switch (signature.charAt(0)) {
 		case 'B':
 			return ResolvedType.BYTE;
@@ -740,51 +684,49 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	}
 
 	private static String nameToSignature(String name) {
-		if (name.equals("byte")) {
-			return "B";
-		}
-		if (name.equals("char")) {
-			return "C";
-		}
-		if (name.equals("double")) {
-			return "D";
-		}
-		if (name.equals("float")) {
-			return "F";
-		}
-		if (name.equals("int")) {
-			return "I";
-		}
-		if (name.equals("long")) {
-			return "J";
-		}
-		if (name.equals("short")) {
-			return "S";
-		}
-		if (name.equals("boolean")) {
-			return "Z";
-		}
-		if (name.equals("void")) {
-			return "V";
-		}
-		if (name.equals("?")) {
-			return name;
+		int len = name.length();
+		if (len < 8) {
+			if (name.equals("byte")) {
+				return "B";
+			}
+			if (name.equals("char")) {
+				return "C";
+			}
+			if (name.equals("double")) {
+				return "D";
+			}
+			if (name.equals("float")) {
+				return "F";
+			}
+			if (name.equals("int")) {
+				return "I";
+			}
+			if (name.equals("long")) {
+				return "J";
+			}
+			if (name.equals("short")) {
+				return "S";
+			}
+			if (name.equals("boolean")) {
+				return "Z";
+			}
+			if (name.equals("void")) {
+				return "V";
+			}
+			if (name.equals("?")) {
+				return name;
+			}
 		}
 		if (name.endsWith("[]")) {
 			return "[" + nameToSignature(name.substring(0, name.length() - 2));
 		}
-		if (name.length() != 0) {
-			// lots more tests could be made here...
-
+		if (len != 0) {
 			// check if someone is calling us with something that is a signature already
-			if (name.charAt(0) == '[') {
-				throw new BCException("Do not call nameToSignature with something that looks like a signature (descriptor): '"
-						+ name + "'");
-			}
+			assert name.charAt(0) != '[';
 
 			if (name.indexOf("<") == -1) {
-				// not parameterised
-				return "L" + name.replace('.', '/') + ";";
+				// not parameterized
+				return new StringBuilder("L").append(name.replace('.', '/')).append(';').toString();
 			} else {
 				StringBuffer nameBuff = new StringBuffer();
 				int nestLevel = 0;
@@ -835,40 +777,27 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 		}
 	}
 
+	/**
+	 * Write out an UnresolvedType - the signature should be enough.
+	 */
 	public final void write(CompressingDataOutputStream s) throws IOException {
 		s.writeUTF(getSignature());
 	}
 
+	/**
+	 * Read in an UnresolvedType - just read the signature and rebuild the UnresolvedType.
+	 */
 	public static UnresolvedType read(DataInputStream s) throws IOException {
 		String sig = s.readUTF();
 		if (sig.equals(MISSING_NAME)) {
 			return ResolvedType.MISSING;
 		} else {
-			UnresolvedType ret = UnresolvedType.forSignature(sig);
-			return ret;
+			// TODO isn't it a shame to build these (this method is expensive) and then chuck them away on resolution?
+			// TODO review callers and see if they are immediately resolving it, maybe we can do something more optimal if they are
+			return UnresolvedType.forSignature(sig);
 		}
 	}
 
-	public static void writeArray(UnresolvedType[] types, CompressingDataOutputStream s) throws IOException {
-		int len = types.length;
-		s.writeShort(len);
-		for (int i = 0; i < len; i++) {
-			types[i].write(s);
-		}
-	}
-
-	public static UnresolvedType[] readArray(DataInputStream s) throws IOException {
-		int len = s.readShort();
-		if (len == 0) {
-			return UnresolvedType.NONE;
-		}
-		UnresolvedType[] types = new UnresolvedType[len];
-		for (int i = 0; i < len; i++) {
-			types[i] = UnresolvedType.read(s);
-		}
-		return types;
-	}
-
 	public String getNameAsIdentifier() {
 		return getName().replace('.', '_');
 	}
@@ -883,42 +812,10 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 		}
 	}
 
-	public String getPackageName() {
-		if (packageName == null) {
-			String name = getName();
-			if (name.indexOf("<") != -1) {
-				name = name.substring(0, name.indexOf("<"));
-			}
-			int index = name.lastIndexOf('.');
-			if (index == -1) {
-				packageName = "";
-			} else {
-				packageName = name.substring(0, index);
-			}
-		}
-		return packageName;
-	}
-
 	public UnresolvedType[] getTypeParameters() {
 		return typeParameters == null ? UnresolvedType.NONE : typeParameters;
 	}
 
-	/**
-	 * Doesn't include the package
-	 */
-	public String getClassName() {
-		if (className == null) {
-			String name = getName();
-			int index = name.lastIndexOf('.');
-			if (index == -1) {
-				className = name;
-			} else {
-				className = name.substring(index + 1);
-			}
-		}
-		return className;
-	}
-
 	public TypeVariable[] getTypeVariables() {
 		return typeVariables;
 	}
@@ -973,4 +870,70 @@ public class UnresolvedType implements Traceable, TypeVariableDeclaringElement {
 	public UnresolvedType parameterize(Map<String, UnresolvedType> typeBindings) {
 		throw new UnsupportedOperationException("unable to parameterize unresolved type: " + signature);
 	}
+
+	/**
+	 * @return the class name (does not include the package name)
+	 */
+	public String getClassName() {
+		if (className == null) {
+			String name = getName();
+			int index = name.lastIndexOf('.');
+			if (index == -1) {
+				className = name;
+			} else {
+				className = name.substring(index + 1);
+			}
+		}
+		return className;
+	}
+
+	/**
+	 * @return the package name (no class name included)
+	 */
+	public String getPackageName() {
+		if (packageName == null) {
+			String name = getName();
+			if (name.indexOf("<") != -1) {
+				name = name.substring(0, name.indexOf("<"));
+			}
+			int index = name.lastIndexOf('.');
+			if (index == -1) {
+				packageName = "";
+			} else {
+				packageName = name.substring(0, index);
+			}
+		}
+		return packageName;
+	}
+
+	// TODO these move to a TypeUtils class
+
+	public static void writeArray(UnresolvedType[] types, CompressingDataOutputStream stream) throws IOException {
+		int len = types.length;
+		stream.writeShort(len);
+		for (UnresolvedType type : types) {
+			type.write(stream);
+		}
+	}
+
+	public static UnresolvedType[] readArray(DataInputStream s) throws IOException {
+		int len = s.readShort();
+		if (len == 0) {
+			return UnresolvedType.NONE;
+		}
+		UnresolvedType[] types = new UnresolvedType[len];
+		for (int i = 0; i < len; i++) {
+			types[i] = UnresolvedType.read(s);
+		}
+		return types;
+	}
+
+	public static UnresolvedType makeArray(UnresolvedType base, int dims) {
+		StringBuffer sig = new StringBuffer();
+		for (int i = 0; i < dims; i++) {
+			sig.append("[");
+		}
+		sig.append(base.getSignature());
+		return UnresolvedType.forSignature(sig.toString());
+	}
 }
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedTypeVariableReferenceType.java b/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedTypeVariableReferenceType.java
index 2dcbbd91a..5510c29d5 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedTypeVariableReferenceType.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/UnresolvedTypeVariableReferenceType.java
@@ -8,7 +8,6 @@
  * ******************************************************************/
 package org.aspectj.weaver;
 
-
 /**
  * @author Adrian Colyer
  * @author Andy Clement
@@ -23,13 +22,14 @@ public class UnresolvedTypeVariableReferenceType extends UnresolvedType implemen
 	}
 
 	public UnresolvedTypeVariableReferenceType(TypeVariable aTypeVariable) {
-		super(aTypeVariable.getFirstBound().getSignature());
+		super("T" + aTypeVariable.getName() + ";", aTypeVariable.getFirstBound().getErasureSignature());//aTypeVariable.getFirstBound().getSignature());
 		this.typeVariable = aTypeVariable;
 	}
 
 	// only used when resolving circular refs...
 	public void setTypeVariable(TypeVariable aTypeVariable) {
 		this.signature = "T" + aTypeVariable.getName() + ";"; // aTypeVariable.getUpperBound().getSignature();
+		this.signatureErasure = aTypeVariable.getFirstBound().getErasureSignature();
 		this.typeVariable = aTypeVariable;
 		this.typeKind = TypeKind.TYPE_VARIABLE;
 	}
diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java b/org.aspectj.matcher/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
index 8934a7512..56492c3f2 100644
--- a/org.aspectj.matcher/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
@@ -181,7 +181,7 @@ public class WildAnnotationTypePattern extends AnnotationTypePattern {
 						} else {
 							throw new RuntimeException("Not implemented for " + t);
 						}
-					} else if (t.equals(ResolvedType.JAVA_LANG_STRING)) {
+					} else if (t.equals(ResolvedType.JL_STRING)) {
 						// nothing to do, it will be OK
 					} else {
 						throw new RuntimeException("Compiler limitation: annotation value support not implemented for type " + t);
diff --git a/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java b/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
index 5b646c5df..234e387de 100644
--- a/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
+++ b/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
@@ -33,6 +33,7 @@ public class MatcherModuleTests extends TestCase {
 		suite.addTestSuite(ReflectionWorldSpecificTest.class);
 		suite.addTestSuite(ReflectionWorldBasicTest.class);
 		suite.addTestSuite(ReflectionWorldPointcutExpressionTests.class);
+		suite.addTestSuite(TypeFactoryTests.class);
 		suite.addTest(PatternsTests.suite());
 		return suite;
 	}
diff --git a/org.aspectj.matcher/testsrc/org/aspectj/weaver/TypeFactoryTests.java b/org.aspectj.matcher/testsrc/org/aspectj/weaver/TypeFactoryTests.java
new file mode 100644
index 000000000..40fed411a
--- /dev/null
+++ b/org.aspectj.matcher/testsrc/org/aspectj/weaver/TypeFactoryTests.java
@@ -0,0 +1,76 @@
+/* *******************************************************************
+ * Copyright (c) 2010 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import junit.framework.TestCase;
+
+/**
+ * Check signature to type mapping.
+ * 
+ * @author Andy Clement
+ */
+public class TypeFactoryTests extends TestCase {
+
+	public void testParameterizedSig() {
+		UnresolvedType t = null;
+		t = UnresolvedType.forSignature("Pjava/util/List<Ljava/lang/String;>;");
+		assertEquals("Ljava/util/List;", t.getErasureSignature());
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signature);
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signatureErasure);
+		assertEquals("Pjava/util/List<Ljava/lang/String;>;", t.getSignature());
+
+		t = TypeFactory.createTypeFromSignature("Ljava/util/List<Ljava/lang/String;>;");
+		assertEquals("Ljava/util/List;", t.getErasureSignature());
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signature);
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signatureErasure);
+		assertEquals("Pjava/util/List<Ljava/lang/String;>;", t.getSignature());
+
+		t = UnresolvedType.forName("java.util.List<java.lang.String>");
+		assertEquals("Ljava/util/List;", t.getErasureSignature());
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signature);
+		assertEquals("Ljava/lang/String;", t.getTypeParameters()[0].signatureErasure);
+		assertEquals("Pjava/util/List<Ljava/lang/String;>;", t.getSignature());
+
+		t = UnresolvedType.forSignature("Pjava/util/Map<TS;Pjava/util/List<Ljava/lang/String;>;>;");
+		assertEquals("Ljava/util/Map;", t.getErasureSignature());
+		assertEquals("TS;", t.getTypeParameters()[0].signature);
+		assertEquals("Ljava/lang/Object;", t.getTypeParameters()[0].signatureErasure);
+		assertEquals("S", ((UnresolvedTypeVariableReferenceType) t.getTypeParameters()[0]).getTypeVariable().getName());
+		assertEquals("Pjava/util/Map<TS;Pjava/util/List<Ljava/lang/String;>;>;", t.getSignature());
+		assertEquals("Pjava/util/List<Ljava/lang/String;>;", t.getTypeParameters()[1].signature);
+		assertEquals("Ljava/util/List;", t.getTypeParameters()[1].signatureErasure);
+
+		t = UnresolvedType.forSignature("Pjava/util/List<+Pnl/ZoekFoo<TS;Pnl/ZoekCopy<TS;>;>;>;");
+		assertEquals("Ljava/util/List;", t.getErasureSignature());
+		WildcardedUnresolvedType wut = (WildcardedUnresolvedType) t.getTypeParameters()[0];
+		assertEquals("+Pnl/ZoekFoo<TS;Pnl/ZoekCopy<TS;>;>;", wut.signature);
+		assertEquals("Lnl/ZoekFoo;", wut.signatureErasure);
+		assertTrue(wut.isExtends());
+		assertEquals("Pnl/ZoekFoo<TS;Pnl/ZoekCopy<TS;>;>;", wut.getUpperBound().signature);
+		assertEquals("Lnl/ZoekFoo;", wut.getUpperBound().signatureErasure);
+		UnresolvedTypeVariableReferenceType tvar = (UnresolvedTypeVariableReferenceType) wut.getUpperBound().getTypeParameters()[0];
+		assertEquals("Pnl/ZoekFoo<TS;Pnl/ZoekCopy<TS;>;>;", wut.getUpperBound().signature);
+		assertEquals("Lnl/ZoekFoo;", wut.getUpperBound().signatureErasure);
+		assertEquals("S", tvar.getTypeVariable().getName());
+		UnresolvedType t2 = wut.getUpperBound().getTypeParameters()[1];
+		assertEquals("Pnl/ZoekCopy<TS;>;", t2.getSignature());
+		assertEquals("Lnl/ZoekCopy;", t2.getErasureSignature());
+
+		//		//		t = UnresolvedType.forSignature("Ljava/util/List<+Lnl/ZoekFoo<TS;Lnl/ZoekCopy<TS;>;>;>;");
+		//		t = TypeFactory.createTypeFromSignature("Ljava/util/List<+Lnl/ZoekFoo<TS;Lnl/ZoekCopy<TS;>;>;>;");
+		//		System.out.println(t.getSignature());
+		//
+		//		t = TypeFactory.createTypeFromSignature("Ljava/util/List<Lnl/ZoekFoo<Ljava/lang/String;>;>;");
+		//		System.out.println(t.getSignature()); // Pjava/util/List<Lnl/ZoekFoo<Ljava/lang/String;>;>;
+
+		// TODO should be able to cope with nested parameterizations
+		// Foo<String>.Bar<List<Map<String,Integer>>>
+		// both components Foo and Bar of that are parameterized
+	}
+}