import java.util.ArrayList;
import java.util.List;
-import org.aspectj.apache.bcel.classfile.GenericSignatureParser;
-import org.aspectj.apache.bcel.classfile.Signature;
-import org.aspectj.apache.bcel.classfile.Signature.ClassSignature;
import org.aspectj.bridge.ISourceLocation;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignatureParser;
+import org.aspectj.util.GenericSignature.ClassSignature;
public abstract class AbstractReferenceTypeDelegate implements ReferenceTypeDelegate {
}
/**
- * Designed to be overriden by EclipseType to disable collection of shadow
- * mungers during pre-weave compilation phase
+ * Designed to be overriden by EclipseType to disable collection of shadow mungers during pre-weave compilation phase
*/
public boolean doesNotExposeShadowMungers() {
return false;
sourceContext = isc;
}
- public Signature.ClassSignature getGenericClassTypeSignature() {
+ public GenericSignature.ClassSignature getGenericClassTypeSignature() {
if (cachedGenericClassTypeSignature == null) {
String sig = getDeclaredGenericSignature();
if (sig != null) {
return cachedGenericClassTypeSignature;
}
- protected Signature.FormalTypeParameter[] getFormalTypeParametersFromOuterClass() {
+ protected GenericSignature.FormalTypeParameter[] getFormalTypeParametersFromOuterClass() {
List typeParameters = new ArrayList();
ReferenceType outer = (ReferenceType) getOuterClass();
ReferenceTypeDelegate outerDelegate = outer.getDelegate();
AbstractReferenceTypeDelegate outerObjectType = (AbstractReferenceTypeDelegate) outerDelegate;
if (outerObjectType.isNested()) {
- Signature.FormalTypeParameter[] parentParams = outerObjectType.getFormalTypeParametersFromOuterClass();
+ GenericSignature.FormalTypeParameter[] parentParams = outerObjectType.getFormalTypeParametersFromOuterClass();
for (int i = 0; i < parentParams.length; i++) {
typeParameters.add(parentParams[i]);
}
}
- Signature.ClassSignature outerSig = outerObjectType.getGenericClassTypeSignature();
+ GenericSignature.ClassSignature outerSig = outerObjectType.getGenericClassTypeSignature();
if (outerSig != null) {
for (int i = 0; i < outerSig.formalTypeParameters.length; i++) {
typeParameters.add(outerSig.formalTypeParameters[i]);
}
}
- Signature.FormalTypeParameter[] ret = new Signature.FormalTypeParameter[typeParameters.size()];
+ GenericSignature.FormalTypeParameter[] ret = new GenericSignature.FormalTypeParameter[typeParameters.size()];
typeParameters.toArray(ret);
return ret;
}
import java.io.IOException;
import java.util.Map;
-import org.aspectj.apache.bcel.classfile.GenericSignatureParser;
-import org.aspectj.apache.bcel.classfile.Signature;
-import org.aspectj.apache.bcel.classfile.Signature.ClassSignature;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignatureParser;
+import org.aspectj.util.GenericSignature.ClassSignature;
import org.aspectj.weaver.tools.Traceable;
/**
ClassSignature csig = new GenericSignatureParser().parseAsClassSignature(declaredGenericSig);
- Signature.FormalTypeParameter[] ftps = csig.formalTypeParameters;
+ GenericSignature.FormalTypeParameter[] ftps = csig.formalTypeParameters;
ret.typeVariables = new TypeVariable[ftps.length];
for (int i = 0; i < ftps.length; i++) {
- Signature.FormalTypeParameter parameter = ftps[i];
- if (parameter.classBound instanceof Signature.ClassTypeSignature) {
- Signature.ClassTypeSignature cts = (Signature.ClassTypeSignature) parameter.classBound;
+ GenericSignature.FormalTypeParameter parameter = ftps[i];
+ if (parameter.classBound instanceof GenericSignature.ClassTypeSignature) {
+ GenericSignature.ClassTypeSignature cts = (GenericSignature.ClassTypeSignature) parameter.classBound;
ret.typeVariables[i] = new TypeVariable(ftps[i].identifier, UnresolvedType.forSignature(cts.outerType.identifier
+ ";"));
- } else if (parameter.classBound instanceof Signature.TypeVariableSignature) {
- Signature.TypeVariableSignature tvs = (Signature.TypeVariableSignature) parameter.classBound;
+ } else if (parameter.classBound instanceof GenericSignature.TypeVariableSignature) {
+ GenericSignature.TypeVariableSignature tvs = (GenericSignature.TypeVariableSignature) parameter.classBound;
UnresolvedTypeVariableReferenceType utvrt = new UnresolvedTypeVariableReferenceType(new TypeVariable(
tvs.typeVariableName));
ret.typeVariables[i] = new TypeVariable(ftps[i].identifier, utvrt);
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.classfile.Field;
-import org.aspectj.apache.bcel.classfile.GenericSignatureParser;
-import org.aspectj.apache.bcel.classfile.Signature;
import org.aspectj.apache.bcel.classfile.Synthetic;
import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
import org.aspectj.apache.bcel.generic.FieldGen;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignatureParser;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
private boolean isAjSynthetic;
private boolean isSynthetic = false;
private AnnotationAJ[] annotations;
- private World world;
- private BcelObjectType bcelObjectType;
+ private final World world;
+ private final BcelObjectType bcelObjectType;
private UnresolvedType genericFieldType = null;
private boolean unpackedGenericSignature = false;
private boolean annotationsAdded = false;
String gSig = field.getGenericSignature();
if (gSig != null) {
// get from generic
- Signature.FieldTypeSignature fts = new GenericSignatureParser().parseAsFieldSignature(gSig);
- Signature.ClassSignature genericTypeSig = bcelObjectType.getGenericClassTypeSignature();
+ GenericSignature.FieldTypeSignature fts = new GenericSignatureParser().parseAsFieldSignature(gSig);
+ GenericSignature.ClassSignature genericTypeSig = bcelObjectType.getGenericClassTypeSignature();
- Signature.FormalTypeParameter[] parentFormals = bcelObjectType.getAllFormals();
- Signature.FormalTypeParameter[] typeVars = ((genericTypeSig == null) ? new Signature.FormalTypeParameter[0]
+ GenericSignature.FormalTypeParameter[] parentFormals = bcelObjectType.getAllFormals();
+ GenericSignature.FormalTypeParameter[] typeVars = ((genericTypeSig == null) ? new GenericSignature.FormalTypeParameter[0]
: genericTypeSig.formalTypeParameters);
- Signature.FormalTypeParameter[] formals = new Signature.FormalTypeParameter[parentFormals.length + typeVars.length];
+ GenericSignature.FormalTypeParameter[] formals = new GenericSignature.FormalTypeParameter[parentFormals.length
+ + typeVars.length];
// put method formal in front of type formals for overriding in
// lookup
System.arraycopy(typeVars, 0, formals, 0, typeVars.length);
import java.util.HashMap;
import java.util.Map;
-import org.aspectj.apache.bcel.classfile.Signature;
-import org.aspectj.apache.bcel.classfile.Signature.SimpleClassTypeSignature;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignature.SimpleClassTypeSignature;
import org.aspectj.weaver.BoundedReferenceType;
import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.tools.TraceFactory;
/**
- * A utility class that assists in unpacking constituent parts of
- * generic signature attributes and returning their equivalents in
+ * A utility class that assists in unpacking constituent parts of generic signature attributes and returning their equivalents in
* UnresolvedType world.
*/
public class BcelGenericSignatureToTypeXConverter {
private static Trace trace = TraceFactory.getTraceFactory().getTrace(BcelGenericSignatureToTypeXConverter.class);
-
- public static ResolvedType classTypeSignature2TypeX(
- Signature.ClassTypeSignature aClassTypeSignature,
- Signature.FormalTypeParameter[] typeParams,
- World world)
- throws GenericSignatureFormatException
- {
+
+ public static ResolvedType classTypeSignature2TypeX(GenericSignature.ClassTypeSignature aClassTypeSignature,
+ GenericSignature.FormalTypeParameter[] typeParams, World world) throws GenericSignatureFormatException {
Map typeMap = new HashMap();
- ResolvedType ret = classTypeSignature2TypeX(aClassTypeSignature,typeParams,world,typeMap);
+ ResolvedType ret = classTypeSignature2TypeX(aClassTypeSignature, typeParams, world, typeMap);
fixUpCircularDependencies(ret, typeMap);
return ret;
}
-
-
- private static ResolvedType classTypeSignature2TypeX(
- Signature.ClassTypeSignature aClassTypeSignature,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
+
+ private static ResolvedType classTypeSignature2TypeX(GenericSignature.ClassTypeSignature aClassTypeSignature,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
// class type sig consists of an outer type, and zero or more nested types
// the fully qualified name is outer-type.nested-type1.nested-type2....
// each type in the hierarchy may have type arguments
-
+
// first build the 'raw type' signature
StringBuffer sig = new StringBuffer();
- sig.append(aClassTypeSignature.outerType.identifier.replace(';',' ').trim());
+ sig.append(aClassTypeSignature.outerType.identifier.replace(';', ' ').trim());
for (int i = 0; i < aClassTypeSignature.nestedTypes.length; i++) {
- sig.append("$");
- sig.append(aClassTypeSignature.nestedTypes[i].identifier.replace(';',' ').trim());
+ sig.append("$");
+ sig.append(aClassTypeSignature.nestedTypes[i].identifier.replace(';', ' ').trim());
}
sig.append(";");
-
+
// now look for any type parameters.
// I *think* we only need to worry about the 'right-most' type...
SimpleClassTypeSignature innerType = aClassTypeSignature.outerType;
if (aClassTypeSignature.nestedTypes.length > 0) {
- innerType = aClassTypeSignature.nestedTypes[aClassTypeSignature.nestedTypes.length-1];
+ innerType = aClassTypeSignature.nestedTypes[aClassTypeSignature.nestedTypes.length - 1];
}
if (innerType.typeArguments.length > 0) {
// we have to create a parameterized type
// type arguments may be array types, class types, or typevariable types
ResolvedType theBaseType = UnresolvedType.forSignature(sig.toString()).resolve(world);
-
+
// Sometimes we may find that when the code is being load-time woven that the types have changed.
// Perhaps an old form of a library jar is being used - this can mean we discover right here
- // that a type is not parameterizable (is that a word?). I think in these cases it is ok to
+ // that a type is not parameterizable (is that a word?). I think in these cases it is ok to
// just return with what we know (the base type). (see pr152848)
if (!(theBaseType.isGenericType() || theBaseType.isRawType())) {
- if (trace.isTraceEnabled()) trace.event("classTypeSignature2TypeX: this type is not a generic type:",null,new Object[]{theBaseType});
+ if (trace.isTraceEnabled())
+ trace.event("classTypeSignature2TypeX: this type is not a generic type:", null, new Object[] { theBaseType });
return theBaseType;
}
-
+
ResolvedType[] typeArgumentTypes = new ResolvedType[innerType.typeArguments.length];
for (int i = 0; i < typeArgumentTypes.length; i++) {
- typeArgumentTypes[i] = typeArgument2TypeX(innerType.typeArguments[i],typeParams,world,inProgressTypeVariableResolutions);
+ typeArgumentTypes[i] = typeArgument2TypeX(innerType.typeArguments[i], typeParams, world,
+ inProgressTypeVariableResolutions);
}
- return
- TypeFactory.createParameterizedType(
- theBaseType,
- typeArgumentTypes,
- world);
-
-// world.resolve(UnresolvedType.forParameterizedTypes(
-// UnresolvedType.forSignature(sig.toString()).resolve(world),
-// typeArgumentTypes));
+ return TypeFactory.createParameterizedType(theBaseType, typeArgumentTypes, world);
+
+ // world.resolve(UnresolvedType.forParameterizedTypes(
+ // UnresolvedType.forSignature(sig.toString()).resolve(world),
+ // typeArgumentTypes));
} else {
// we have a non-parameterized type
return world.resolve(UnresolvedType.forSignature(sig.toString()));
}
}
-
- public static ResolvedType fieldTypeSignature2TypeX(
- Signature.FieldTypeSignature aFieldTypeSignature,
- Signature.FormalTypeParameter[] typeParams,
- World world)
- throws GenericSignatureFormatException
- {
+
+ public static ResolvedType fieldTypeSignature2TypeX(GenericSignature.FieldTypeSignature aFieldTypeSignature,
+ GenericSignature.FormalTypeParameter[] typeParams, World world) throws GenericSignatureFormatException {
Map typeMap = new HashMap();
- ResolvedType ret = fieldTypeSignature2TypeX(aFieldTypeSignature,typeParams,world,typeMap);
+ ResolvedType ret = fieldTypeSignature2TypeX(aFieldTypeSignature, typeParams, world, typeMap);
fixUpCircularDependencies(ret, typeMap);
return ret;
}
-
- private static ResolvedType fieldTypeSignature2TypeX(
- Signature.FieldTypeSignature aFieldTypeSignature,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
+
+ private static ResolvedType fieldTypeSignature2TypeX(GenericSignature.FieldTypeSignature aFieldTypeSignature,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
if (aFieldTypeSignature.isClassTypeSignature()) {
- return classTypeSignature2TypeX((Signature.ClassTypeSignature)aFieldTypeSignature,typeParams,world,inProgressTypeVariableResolutions);
+ return classTypeSignature2TypeX((GenericSignature.ClassTypeSignature) aFieldTypeSignature, typeParams, world,
+ inProgressTypeVariableResolutions);
} else if (aFieldTypeSignature.isArrayTypeSignature()) {
int dims = 0;
- Signature.TypeSignature ats = aFieldTypeSignature;
- while(ats instanceof Signature.ArrayTypeSignature) {
+ GenericSignature.TypeSignature ats = aFieldTypeSignature;
+ while (ats instanceof GenericSignature.ArrayTypeSignature) {
dims++;
- ats = ((Signature.ArrayTypeSignature)ats).typeSig;
+ ats = ((GenericSignature.ArrayTypeSignature) ats).typeSig;
}
- return world.resolve(UnresolvedType.makeArray(typeSignature2TypeX(ats,typeParams,world,inProgressTypeVariableResolutions), dims));
+ return world.resolve(UnresolvedType.makeArray(typeSignature2TypeX(ats, typeParams, world,
+ inProgressTypeVariableResolutions), dims));
} else if (aFieldTypeSignature.isTypeVariableSignature()) {
- ResolvedType rtx = typeVariableSignature2TypeX((Signature.TypeVariableSignature)aFieldTypeSignature,typeParams,world,inProgressTypeVariableResolutions);
+ ResolvedType rtx = typeVariableSignature2TypeX((GenericSignature.TypeVariableSignature) aFieldTypeSignature,
+ typeParams, world, inProgressTypeVariableResolutions);
return rtx;
} else {
- throw new GenericSignatureFormatException("Cant understand field type signature: " + aFieldTypeSignature);
+ throw new GenericSignatureFormatException("Cant understand field type signature: " + aFieldTypeSignature);
}
}
- public static TypeVariable formalTypeParameter2TypeVariable(
- Signature.FormalTypeParameter aFormalTypeParameter,
- Signature.FormalTypeParameter[] typeParams,
- World world)
- throws GenericSignatureFormatException
- {
+ public static TypeVariable formalTypeParameter2TypeVariable(GenericSignature.FormalTypeParameter aFormalTypeParameter,
+ GenericSignature.FormalTypeParameter[] typeParams, World world) throws GenericSignatureFormatException {
Map typeMap = new HashMap();
- return formalTypeParameter2TypeVariable(aFormalTypeParameter,typeParams,world,typeMap);
+ return formalTypeParameter2TypeVariable(aFormalTypeParameter, typeParams, world, typeMap);
}
- private static TypeVariable formalTypeParameter2TypeVariable(
- Signature.FormalTypeParameter aFormalTypeParameter,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
- UnresolvedType upperBound = fieldTypeSignature2TypeX(aFormalTypeParameter.classBound,typeParams,world,inProgressTypeVariableResolutions);
- UnresolvedType[] ifBounds = new UnresolvedType[aFormalTypeParameter.interfaceBounds.length];
- for (int i = 0; i < ifBounds.length; i++) {
- ifBounds[i] = fieldTypeSignature2TypeX(aFormalTypeParameter.interfaceBounds[i], typeParams,world,inProgressTypeVariableResolutions);
- }
- return new TypeVariable(aFormalTypeParameter.identifier,upperBound,ifBounds);
+ private static TypeVariable formalTypeParameter2TypeVariable(GenericSignature.FormalTypeParameter aFormalTypeParameter,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
+ UnresolvedType upperBound = fieldTypeSignature2TypeX(aFormalTypeParameter.classBound, typeParams, world,
+ inProgressTypeVariableResolutions);
+ UnresolvedType[] ifBounds = new UnresolvedType[aFormalTypeParameter.interfaceBounds.length];
+ for (int i = 0; i < ifBounds.length; i++) {
+ ifBounds[i] = fieldTypeSignature2TypeX(aFormalTypeParameter.interfaceBounds[i], typeParams, world,
+ inProgressTypeVariableResolutions);
+ }
+ return new TypeVariable(aFormalTypeParameter.identifier, upperBound, ifBounds);
}
-
- private static ResolvedType typeArgument2TypeX(
- Signature.TypeArgument aTypeArgument,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
- if (aTypeArgument.isWildcard) return UnresolvedType.SOMETHING.resolve(world);
+
+ private static ResolvedType typeArgument2TypeX(GenericSignature.TypeArgument aTypeArgument,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
+ if (aTypeArgument.isWildcard)
+ return UnresolvedType.SOMETHING.resolve(world);
if (aTypeArgument.isMinus) {
- UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams,world,inProgressTypeVariableResolutions);
+ UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world,
+ inProgressTypeVariableResolutions);
ReferenceType rBound = (ReferenceType) world.resolve(bound);
- return new BoundedReferenceType(rBound,false,world);
+ return new BoundedReferenceType(rBound, false, world);
} else if (aTypeArgument.isPlus) {
- UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams,world,inProgressTypeVariableResolutions);
+ UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world,
+ inProgressTypeVariableResolutions);
ReferenceType rBound = (ReferenceType) world.resolve(bound);
- return new BoundedReferenceType(rBound,true,world);
+ return new BoundedReferenceType(rBound, true, world);
} else {
- return fieldTypeSignature2TypeX(aTypeArgument.signature,typeParams,world,inProgressTypeVariableResolutions);
+ return fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world, inProgressTypeVariableResolutions);
}
}
-
- public static ResolvedType typeSignature2TypeX(
- Signature.TypeSignature aTypeSig,
- Signature.FormalTypeParameter[] typeParams,
- World world)
- throws GenericSignatureFormatException
- {
+ public static ResolvedType typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig,
+ GenericSignature.FormalTypeParameter[] typeParams, World world) throws GenericSignatureFormatException {
Map typeMap = new HashMap();
- ResolvedType ret = typeSignature2TypeX(aTypeSig,typeParams,world,typeMap);
+ ResolvedType ret = typeSignature2TypeX(aTypeSig, typeParams, world, typeMap);
fixUpCircularDependencies(ret, typeMap);
return ret;
}
-
- private static ResolvedType typeSignature2TypeX(
- Signature.TypeSignature aTypeSig,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
+
+ private static ResolvedType typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
if (aTypeSig.isBaseType()) {
- return world.resolve(UnresolvedType.forSignature(((Signature.BaseTypeSignature)aTypeSig).toString()));
+ return world.resolve(UnresolvedType.forSignature(((GenericSignature.BaseTypeSignature) aTypeSig).toString()));
} else {
- return fieldTypeSignature2TypeX((Signature.FieldTypeSignature)aTypeSig,typeParams,world,inProgressTypeVariableResolutions);
+ return fieldTypeSignature2TypeX((GenericSignature.FieldTypeSignature) aTypeSig, typeParams, world,
+ inProgressTypeVariableResolutions);
}
}
-
- private static ResolvedType typeVariableSignature2TypeX(
- Signature.TypeVariableSignature aTypeVarSig,
- Signature.FormalTypeParameter[] typeParams,
- World world,
- Map inProgressTypeVariableResolutions)
- throws GenericSignatureFormatException
- {
- Signature.FormalTypeParameter typeVarBounds = null;
+
+ private static ResolvedType typeVariableSignature2TypeX(GenericSignature.TypeVariableSignature aTypeVarSig,
+ GenericSignature.FormalTypeParameter[] typeParams, World world, Map inProgressTypeVariableResolutions)
+ throws GenericSignatureFormatException {
+ GenericSignature.FormalTypeParameter typeVarBounds = null;
for (int i = 0; i < typeParams.length; i++) {
if (typeParams[i].identifier.equals(aTypeVarSig.typeVariableName)) {
typeVarBounds = typeParams[i];
}
}
if (typeVarBounds == null) {
- // blowing up here breaks the situation with ITDs where the type variable is mentioned in the
- // declaring type and used somewhere in the signature. Temporary change to allow it to return just a
+ // blowing up here breaks the situation with ITDs where the type variable is mentioned in the
+ // declaring type and used somewhere in the signature. Temporary change to allow it to return just a
// 'dumb' typevariablereference.
- return new TypeVariableReferenceType(new TypeVariable(aTypeVarSig.typeVariableName),world);
+ return new TypeVariableReferenceType(new TypeVariable(aTypeVarSig.typeVariableName), world);
// throw new GenericSignatureFormatException("Undeclared type variable in signature: " + aTypeVarSig.typeVariableName);
}
if (inProgressTypeVariableResolutions.containsKey(typeVarBounds)) {
return (ResolvedType) inProgressTypeVariableResolutions.get(typeVarBounds);
}
- inProgressTypeVariableResolutions.put(typeVarBounds,new FTPHolder(typeVarBounds,world));
- ResolvedType ret = new TypeVariableReferenceType(
- formalTypeParameter2TypeVariable(typeVarBounds,typeParams,world,inProgressTypeVariableResolutions),
- world);
- inProgressTypeVariableResolutions.put(typeVarBounds,ret);
+ inProgressTypeVariableResolutions.put(typeVarBounds, new FTPHolder(typeVarBounds, world));
+ ResolvedType ret = new TypeVariableReferenceType(formalTypeParameter2TypeVariable(typeVarBounds, typeParams, world,
+ inProgressTypeVariableResolutions), world);
+ inProgressTypeVariableResolutions.put(typeVarBounds, ret);
return ret;
}
-
+
private static void fixUpCircularDependencies(ResolvedType aTypeX, Map typeVariableResolutions) {
- if (! (aTypeX instanceof ReferenceType)) return;
-
+ if (!(aTypeX instanceof ReferenceType))
+ return;
+
ReferenceType rt = (ReferenceType) aTypeX;
TypeVariable[] typeVars = rt.getTypeVariables();
if (typeVars != null) {
- for (int i = 0; i < typeVars.length; i++) {
- if (typeVars[i].getUpperBound() instanceof FTPHolder) {
- Signature.FormalTypeParameter key = ((FTPHolder) typeVars[i].getUpperBound()).ftpToBeSubstituted;
- typeVars[i].setUpperBound((UnresolvedType) typeVariableResolutions.get(key));
- }
- }
+ for (int i = 0; i < typeVars.length; i++) {
+ if (typeVars[i].getUpperBound() instanceof FTPHolder) {
+ GenericSignature.FormalTypeParameter key = ((FTPHolder) typeVars[i].getUpperBound()).ftpToBeSubstituted;
+ typeVars[i].setUpperBound((UnresolvedType) typeVariableResolutions.get(key));
+ }
+ }
}
}
-
+
private static class FTPHolder extends ReferenceType {
- public Signature.FormalTypeParameter ftpToBeSubstituted;
- public FTPHolder(Signature.FormalTypeParameter ftp, World world) {
- super("Ljava/lang/Object;",world);
+ public GenericSignature.FormalTypeParameter ftpToBeSubstituted;
+
+ public FTPHolder(GenericSignature.FormalTypeParameter ftp, World world) {
+ super("Ljava/lang/Object;", world);
this.ftpToBeSubstituted = ftp;
}
+
public String toString() {
return "placeholder for TypeVariable of " + ftpToBeSubstituted.toString();
}
+
public ResolvedType resolve(World world) {
return this;
}
}
-
+
public static class GenericSignatureFormatException extends Exception {
public GenericSignatureFormatException(String explanation) {
super(explanation);
import org.aspectj.apache.bcel.classfile.AnnotationDefault;
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.ExceptionTable;
-import org.aspectj.apache.bcel.classfile.GenericSignatureParser;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.LineNumber;
import org.aspectj.apache.bcel.classfile.LineNumberTable;
import org.aspectj.apache.bcel.classfile.LocalVariable;
import org.aspectj.apache.bcel.classfile.LocalVariableTable;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.Signature;
-import org.aspectj.apache.bcel.classfile.Signature.TypeVariableSignature;
import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.SourceLocation;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignatureParser;
+import org.aspectj.util.GenericSignature.TypeVariableSignature;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
}
/**
- * A method can be parameterized if it has one or more generic parameters. A
- * generic parameter (type variable parameter) is identified by the prefix
- * "T"
+ * A method can be parameterized if it has one or more generic parameters. A generic parameter (type variable parameter) is
+ * identified by the prefix "T"
*/
public boolean canBeParameterized() {
unpackGenericSignature();
}
/**
- * Return the parameterized/generic return type or the normal return type if
- * the method is not generic.
+ * Return the parameterized/generic return type or the normal return type if the method is not generic.
*/
public UnresolvedType getGenericReturnType() {
unpackGenericSignature();
}
String gSig = method.getGenericSignature();
if (gSig != null) {
- Signature.MethodTypeSignature mSig = new GenericSignatureParser().parseAsMethodSignature(gSig);// method
- // .
+ GenericSignature.MethodTypeSignature mSig = new GenericSignatureParser().parseAsMethodSignature(gSig);// method
+ // .
// getGenericSignature
// ());
if (mSig.formalTypeParameters.length > 0) {
typeVariables = new TypeVariable[mSig.formalTypeParameters.length];
for (int i = 0; i < typeVariables.length; i++) {
- Signature.FormalTypeParameter methodFtp = mSig.formalTypeParameters[i];
+ GenericSignature.FormalTypeParameter methodFtp = mSig.formalTypeParameters[i];
try {
typeVariables[i] = BcelGenericSignatureToTypeXConverter.formalTypeParameter2TypeVariable(methodFtp,
mSig.formalTypeParameters, bcelObjectType.getWorld());
}
}
- Signature.FormalTypeParameter[] parentFormals = bcelObjectType.getAllFormals();
- Signature.FormalTypeParameter[] formals = new Signature.FormalTypeParameter[parentFormals.length
+ GenericSignature.FormalTypeParameter[] parentFormals = bcelObjectType.getAllFormals();
+ GenericSignature.FormalTypeParameter[] formals = new GenericSignature.FormalTypeParameter[parentFormals.length
+ mSig.formalTypeParameters.length];
// put method formal in front of type formals for overriding in
// lookup
System.arraycopy(mSig.formalTypeParameters, 0, formals, 0, mSig.formalTypeParameters.length);
System.arraycopy(parentFormals, 0, formals, mSig.formalTypeParameters.length, parentFormals.length);
- Signature.TypeSignature returnTypeSignature = mSig.returnType;
+ GenericSignature.TypeSignature returnTypeSignature = mSig.returnType;
try {
genericReturnType = BcelGenericSignatureToTypeXConverter.typeSignature2TypeX(returnTypeSignature, formals,
bcelObjectType.getWorld());
throw new IllegalStateException("While determing the generic return type of " + this.toString()
+ " with generic signature " + gSig + " the following error was detected: " + e.getMessage());
}
- Signature.TypeSignature[] paramTypeSigs = mSig.parameters;
+ GenericSignature.TypeSignature[] paramTypeSigs = mSig.parameters;
genericParameterTypes = new UnresolvedType[paramTypeSigs.length];
for (int i = 0; i < paramTypeSigs.length; i++) {
try {
}
/**
- * Returns whether or not the given object is equivalent to the current one.
- * Returns true if getMethod().getCode().getCodeString() are equal. Allows
- * for different line number tables.
+ * Returns whether or not the given object is equivalent to the current one. Returns true if
+ * getMethod().getCode().getCodeString() are equal. Allows for different line number tables.
*/
// bug 154054: is similar to equals(Object) however
// doesn't require implementing equals in Method and Code
import org.aspectj.apache.bcel.classfile.annotation.EnumElementValueGen;
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.MessageUtil;
+import org.aspectj.util.GenericSignature;
import org.aspectj.weaver.AbstractReferenceTypeDelegate;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
private List typeMungers = Collections.EMPTY_LIST;
private List declares = Collections.EMPTY_LIST;
- private Signature.FormalTypeParameter[] formalsForResolution = null;
+ private GenericSignature.FormalTypeParameter[] formalsForResolution = null;
private String declaredSignature = null;
private boolean hasBeenWoven = false;
return TypeVariable.NONE;
if (typeVars == null) {
- Signature.ClassSignature classSig = getGenericClassTypeSignature();// cachedGenericClassTypeSignature
+ GenericSignature.ClassSignature classSig = getGenericClassTypeSignature();// cachedGenericClassTypeSignature
// ;
// /
// /
// getGenericClassTypeSignature();
typeVars = new TypeVariable[classSig.formalTypeParameters.length];
for (int i = 0; i < typeVars.length; i++) {
- Signature.FormalTypeParameter ftp = classSig.formalTypeParameters[i];
+ GenericSignature.FormalTypeParameter ftp = classSig.formalTypeParameters[i];
try {
typeVars[i] = BcelGenericSignatureToTypeXConverter.formalTypeParameter2TypeVariable(ftp,
classSig.formalTypeParameters, getResolvedTypeX().getWorld());
bitflag |= UNPACKED_GENERIC_SIGNATURE;
if (!getResolvedTypeX().getWorld().isInJava5Mode())
return;
- Signature.ClassSignature cSig = getGenericClassTypeSignature();
+ GenericSignature.ClassSignature cSig = getGenericClassTypeSignature();
if (cSig != null) {
formalsForResolution = cSig.formalTypeParameters;
if (isNested()) {
// we have to find any type variables from the outer type before
// proceeding with resolution.
- Signature.FormalTypeParameter[] extraFormals = getFormalTypeParametersFromOuterClass();
+ GenericSignature.FormalTypeParameter[] extraFormals = getFormalTypeParametersFromOuterClass();
if (extraFormals.length > 0) {
List allFormals = new ArrayList();
for (int i = 0; i < formalsForResolution.length; i++) {
for (int i = 0; i < extraFormals.length; i++) {
allFormals.add(extraFormals[i]);
}
- formalsForResolution = new Signature.FormalTypeParameter[allFormals.size()];
+ formalsForResolution = new GenericSignature.FormalTypeParameter[allFormals.size()];
allFormals.toArray(formalsForResolution);
}
}
- Signature.ClassTypeSignature superSig = cSig.superclassSignature;
+ GenericSignature.ClassTypeSignature superSig = cSig.superclassSignature;
try {
// this.superClass =
// BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
}
}
- public Signature.FormalTypeParameter[] getAllFormals() {
+ public GenericSignature.FormalTypeParameter[] getAllFormals() {
ensureGenericSignatureUnpacked();
if (formalsForResolution == null) {
- return new Signature.FormalTypeParameter[0];
+ return new GenericSignature.FormalTypeParameter[0];
} else {
return formalsForResolution;
}
package org.aspectj.weaver;
+
/* *******************************************************************
* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
* All rights reserved.
* ******************************************************************/
// default package
-
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class BcweaverModuleTests extends TestCase {
- public static Test suite() {
- TestSuite suite = new TestSuite(BcweaverModuleTests.class.getName());
- suite.addTest(org.aspectj.weaver.bcel.BcelTests.suite());
- suite.addTest(org.aspectj.weaver.BcweaverTests.suite());
- suite.addTest(org.aspectj.weaver.patterns.PatternsTests.suite());
- suite.addTestSuite(LocaleTest.class);
- suite.addTest(ToolsTests.suite());
- return suite;
- }
+ public static Test suite() {
+ TestSuite suite = new TestSuite(BcweaverModuleTests.class.getName());
+ suite.addTest(org.aspectj.weaver.bcel.BcelTests.suite());
+ suite.addTest(org.aspectj.weaver.BcweaverTests.suite());
+ suite.addTest(org.aspectj.weaver.patterns.PatternsTests.suite());
+ suite.addTestSuite(LocaleTest.class);
+ suite.addTestSuite(GenericSignatureParserTest.class);
+ suite.addTest(ToolsTests.suite());
+ return suite;
+ }
- public BcweaverModuleTests(String name) { super(name); }
+ public BcweaverModuleTests(String name) {
+ super(name);
+ }
-}
+}
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation,
+ * 2002 Palo Alto Research Center, Incorporated (PARC).
+ * 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
+ *
+ * ******************************************************************/
+ package org.aspectj.weaver;
+
+import junit.framework.TestCase;
+
+import org.aspectj.apache.bcel.classfile.JavaClass;
+import org.aspectj.apache.bcel.classfile.Method;
+import org.aspectj.apache.bcel.util.SyntheticRepository;
+import org.aspectj.util.GenericSignatureParser;
+
+/**
+ * @author Adrian Colyer
+ * @author Andy Clement
+ */
+public class GenericSignatureParserTest extends TestCase {
+
+ GenericSignatureParser parser;
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ parser = new GenericSignatureParser();
+ }
+
+ public void testClassSignatureParsingInJDK() throws Exception {
+ SyntheticRepository repository = SyntheticRepository.getInstance();
+ String[] testClasses = new String[] { "java.lang.Comparable", "java.lang.Iterable", "java.lang.Class", "java.lang.Enum",
+ "java.lang.InheritableThreadLocal", "java.lang.ThreadLocal", "java.util.Collection", "java.util.Comparator",
+ "java.util.Enumeration", "java.util.Iterator", "java.util.List", "java.util.ListIterator", "java.util.Map",
+ "java.util.Map$Entry", "java.util.Queue", "java.util.Set", "java.util.SortedMap", "java.util.SortedSet" };
+ for (int i = 0; i < testClasses.length; i++) {
+ JavaClass jc = repository.loadClass(testClasses[i]);
+ String sig = jc.getGenericSignature();
+ parser.parseAsClassSignature(sig);
+ }
+ }
+
+ public void testMethodSignatureParsingInJDK() throws Exception {
+ SyntheticRepository repository = SyntheticRepository.getInstance();
+ String[] testClasses = new String[] { "java.lang.Comparable", "java.lang.Iterable", "java.lang.Class", "java.lang.Enum",
+ "java.lang.InheritableThreadLocal", "java.lang.ThreadLocal", "java.util.Collection", "java.util.Comparator",
+ "java.util.Enumeration", "java.util.Iterator", "java.util.List", "java.util.ListIterator", "java.util.Map",
+ "java.util.Map$Entry", "java.util.Queue", "java.util.Set", "java.util.SortedMap", "java.util.SortedSet" };
+ for (int i = 0; i < testClasses.length; i++) {
+ JavaClass jc = repository.loadClass(testClasses[i]);
+ Method[] methods = jc.getMethods();
+ for (int j = 0; j < methods.length; j++) {
+ String sig = methods[j].getGenericSignature();
+ if (sig != null)
+ parser.parseAsMethodSignature(sig);
+ }
+ }
+ }
+
+}
import junit.framework.TestCase;
import org.aspectj.apache.bcel.Repository;
-import org.aspectj.apache.bcel.classfile.GenericSignatureParser;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Signature;
+import org.aspectj.util.GenericSignature;
+import org.aspectj.util.GenericSignatureParser;
+import org.aspectj.util.GenericSignature.ClassSignature;
import org.aspectj.weaver.UnresolvedType;
/**
* @author colyer
- *
+ *
*/
public class BcelGenericSignatureToTypeXTestCase extends TestCase {
+ public final GenericSignature.ClassSignature getGenericClassTypeSignature(JavaClass jClass) {
+ Signature sig = jClass.getSignatureAttribute();
+ if (sig != null) {
+ GenericSignatureParser parser = new GenericSignatureParser();
+ ClassSignature classSig = parser.parseAsClassSignature(sig.getSignature());
+ return classSig;
+ }
+ return null;
+ }
+
+ // public final GenericSignature.MethodTypeSignature getGenericMethodTypeSignature(JavaClass jClass) {
+ // Signature sig = jClass.getSignatureAttribute();
+ // if (sig != null) {
+ // GenericSignatureParser parser = new GenericSignatureParser();
+ // MethodTypeSignature mSig = parser.parseAsMethodSignature(sig);
+ // return mSig;
+ // }
+ // return null;
+ // }
+
+ // public FieldTypeSignature asFieldTypeSignature() {
+ // if (fieldSig == null) {
+ // GenericSignatureParser parser = new GenericSignatureParser();
+ // fieldSig = parser.parseAsFieldSignature(getSignature());
+ // }
+ // return fieldSig;
+ // }
+
public void testEnumFromHell() throws Exception {
BcelWorld world = new BcelWorld();
JavaClass javaLangEnum = Repository.lookupClass("java/lang/Enum");
- Signature.ClassSignature cSig = javaLangEnum.getGenericClassTypeSignature();
- UnresolvedType superclass =
- BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- cSig.superclassSignature,
- cSig.formalTypeParameters,
- world
- );
- assertEquals("Ljava/lang/Object;",superclass.getSignature());
- assertEquals("2 superinterfaces",2,cSig.superInterfaceSignatures.length);
- UnresolvedType comparable =
- BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- cSig.superInterfaceSignatures[0],
- cSig.formalTypeParameters,
- world
- );
- assertEquals("Pjava/lang/Comparable<TE;>;",comparable.getSignature());
- UnresolvedType serializable =
- BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- cSig.superInterfaceSignatures[1],
- cSig.formalTypeParameters,
- world
- );
- assertEquals("Ljava/io/Serializable;",serializable.getSignature());
+ GenericSignature.ClassSignature cSig = getGenericClassTypeSignature(javaLangEnum);
+ UnresolvedType superclass = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(cSig.superclassSignature,
+ cSig.formalTypeParameters, world);
+ assertEquals("Ljava/lang/Object;", superclass.getSignature());
+ assertEquals("2 superinterfaces", 2, cSig.superInterfaceSignatures.length);
+ UnresolvedType comparable = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(cSig.superInterfaceSignatures[0],
+ cSig.formalTypeParameters, world);
+ assertEquals("Pjava/lang/Comparable<TE;>;", comparable.getSignature());
+ UnresolvedType serializable = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
+ cSig.superInterfaceSignatures[1], cSig.formalTypeParameters, world);
+ assertEquals("Ljava/io/Serializable;", serializable.getSignature());
}
-
+
public void testColonColon() throws Exception {
BcelWorld world = new BcelWorld();
- Signature.ClassSignature cSig = new GenericSignatureParser().parseAsClassSignature("<T::Ljava/io/Serializable;>Ljava/lang/Object;Ljava/lang/Comparable<TT;>;");
- UnresolvedType resolved = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- cSig.superclassSignature,
- cSig.formalTypeParameters,
- world);
- assertEquals("Ljava/lang/Object;",resolved.getSignature());
-// UnresolvedType resolvedInt =
- BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- cSig.superInterfaceSignatures[0],
- cSig.formalTypeParameters,
+ GenericSignature.ClassSignature cSig = new GenericSignatureParser()
+ .parseAsClassSignature("<T::Ljava/io/Serializable;>Ljava/lang/Object;Ljava/lang/Comparable<TT;>;");
+ UnresolvedType resolved = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(cSig.superclassSignature,
+ cSig.formalTypeParameters, world);
+ assertEquals("Ljava/lang/Object;", resolved.getSignature());
+ // UnresolvedType resolvedInt =
+ BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(cSig.superInterfaceSignatures[0], cSig.formalTypeParameters,
world);
-
+
}
-
+
}
projects / aspectj.git / commitdiff