--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2008 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
+ *
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+
+public abstract class AbstractAnnotationAJ implements AnnotationAJ {
+
+ protected final ResolvedType type;
+
+ private Set supportedTargets = null; // @target meta annotation
+
+ public AbstractAnnotationAJ(ResolvedType type) {
+ this.type = type;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final ResolvedType getType() {
+ return type;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final String getTypeSignature() {
+ return type.getSignature();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final String getTypeName() {
+ return type.getName();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final boolean allowedOnAnnotationType() {
+ ensureAtTargetInitialized();
+ if (supportedTargets.isEmpty()) {
+ return true;
+ }
+ return supportedTargets.contains("ANNOTATION_TYPE");
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final boolean allowedOnField() {
+ ensureAtTargetInitialized();
+ if (supportedTargets.isEmpty()) {
+ return true;
+ }
+ return supportedTargets.contains("FIELD");
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final boolean allowedOnRegularType() {
+ ensureAtTargetInitialized();
+ if (supportedTargets.isEmpty()) {
+ return true;
+ }
+ return supportedTargets.contains("TYPE");
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final void ensureAtTargetInitialized() {
+ if (supportedTargets == null) {
+ AnnotationAJ atTargetAnnotation = retrieveAnnotationOnAnnotation(UnresolvedType.AT_TARGET);
+ if (atTargetAnnotation == null) {
+ supportedTargets = Collections.EMPTY_SET;
+ } else {
+ supportedTargets = atTargetAnnotation.getTargets();
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final String getValidTargets() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("{");
+ for (Iterator iter = supportedTargets.iterator(); iter.hasNext();) {
+ String evalue = (String) iter.next();
+ sb.append(evalue);
+ if (iter.hasNext()) {
+ sb.append(",");
+ }
+ }
+ sb.append("}");
+ return sb.toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public final boolean specifiesTarget() {
+ ensureAtTargetInitialized();
+ return !supportedTargets.isEmpty();
+ }
+
+ /**
+ * Helper method to retrieve an annotation on an annotation e.g. retrieveAnnotationOnAnnotation(UnresolvedType.AT_TARGET)
+ */
+ private final AnnotationAJ retrieveAnnotationOnAnnotation(UnresolvedType requiredAnnotationSignature) {
+ AnnotationAJ[] annos = type.getAnnotations();
+ for (int i = 0; i < annos.length; i++) {
+ AnnotationAJ a = annos[i];
+ if (a.getTypeSignature().equals(requiredAnnotationSignature.getSignature())) {
+ return annos[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract boolean isRuntimeVisible();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Set getTargets();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract boolean hasNameValuePair(String name, String value);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract boolean hasNamedValue(String name);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract String stringify();
+
+}
*/
public interface AnnotatedElement {
boolean hasAnnotation(UnresolvedType ofType);
-
+
ResolvedType[] getAnnotationTypes();
-
- AnnotationX getAnnotationOfType(UnresolvedType ofType);
+
+ AnnotationAJ getAnnotationOfType(UnresolvedType ofType);
}
/* *******************************************************************
- * Copyright (c) 2006 Contributors
+ * Copyright (c) 2006-2008 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 IBM initial implementation
* ******************************************************************/
package org.aspectj.weaver;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
+import java.util.Set;
/**
- * This type represents the weavers abstraction of an annotation - it is
- * not tied to any underlying BCI toolkit. The weaver actualy handles these
- * through AnnotationX wrapper objects - until we start transforming the
- * BCEL annotations into this form (expensive) or offer a clever
- * visitor mechanism over the BCEL annotation stuff that builds these
- * annotation types directly.
- *
+ * Simple representation of an annotation that the weaver can work with.
+ *
* @author AndyClement
*/
-public class AnnotationAJ {
-
- private String type;
- private boolean isRuntimeVisible;
-
- private List /*of AnnotationNVPair*/ nvPairs = null;
-
- public AnnotationAJ(String type,boolean isRuntimeVisible) {
- this.type = type;
- this.isRuntimeVisible = isRuntimeVisible;
- }
-
- public String getTypeSignature() {
- return type;
- }
-
- public List getNameValuePairs() {
- return nvPairs;
- }
-
- public boolean hasNameValuePairs() {
- return nvPairs!=null && nvPairs.size()!=0;
- }
-
- public boolean isRuntimeVisible() {
- return isRuntimeVisible;
- }
-
- public String stringify() {
- StringBuffer sb = new StringBuffer();
- sb.append("@").append(UnresolvedType.forSignature(type).getClassName());
- if (hasNameValuePairs()) {
- sb.append("(");
- for (Iterator iter = nvPairs.iterator(); iter.hasNext();) {
- AnnotationNameValuePair element = (AnnotationNameValuePair) iter.next();
- sb.append(element.stringify());
- }
- sb.append(")");
- }
- return sb.toString();
- }
-
- public String getStringValueOf(Object name) {
- if (!hasNameValuePairs()) return null;
- for (Iterator iter = nvPairs.iterator(); iter.hasNext();) {
- AnnotationNameValuePair nvpair = (AnnotationNameValuePair) iter.next();
- if (nvpair.getName().equals(name)) return nvpair.getValue().stringify();
- }
- return null;
- }
-
- public void addNameValuePair(AnnotationNameValuePair pair) {
- if (nvPairs==null) nvPairs=new ArrayList();
- nvPairs.add(pair);
- }
-
- public String toString() {
- StringBuffer sb = new StringBuffer();
- sb.append("ANNOTATION ["+getTypeSignature()+"] ["+
- (isRuntimeVisible?"runtimeVisible":"runtimeInvisible")+"] [");
- if (nvPairs!=null) {
- for (Iterator iter = nvPairs.iterator(); iter.hasNext();) {
- AnnotationNameValuePair element = (AnnotationNameValuePair) iter.next();
- sb.append(element.toString());
- if (iter.hasNext()) sb.append(",");
- }
- }
- sb.append("]");
- return sb.toString();
- }
-
- public boolean hasNamedValue(String n) {
- if (nvPairs==null) return false;
- for (int i=0;i<nvPairs.size();i++) {
- AnnotationNameValuePair pair = (AnnotationNameValuePair)nvPairs.get(i);
- if (pair.getName().equals(n)) return true;
- }
- return false;
- }
+public interface AnnotationAJ {
+
+ public static final AnnotationAJ[] EMPTY_ARRAY = new AnnotationAJ[0];
+
+ /**
+ * @return the signature for the annotation type, eg. Lcom/foo/MyAnno;
+ */
+ public String getTypeSignature();
+
+ /**
+ * @return the type name for the annotation, eg. com.foo.MyAnno
+ */
+ public String getTypeName();
+
+ /**
+ * @return the type of the annotation
+ */
+ public ResolvedType getType();
+
+ /**
+ * return true if this annotation can target an annotation type
+ */
+ public boolean allowedOnAnnotationType();
+
+ /**
+ * @return true if this annotation can be put on a field
+ */
+ public boolean allowedOnField();
+
+ /**
+ * @return true if this annotation can target a 'regular' type. A 'regular' type is enum/class/interface - it is *not*
+ * annotation.
+ */
+ public boolean allowedOnRegularType();
/**
- * Return true if the annotation has a value with the specified name (n) and value (v)
- */
- public boolean hasNameValuePair(String n, String v) {
- if (nvPairs==null) return false;
- for (int i=0;i<nvPairs.size();i++) {
- AnnotationNameValuePair pair = (AnnotationNameValuePair)nvPairs.get(i);
- if (pair.getName().equals(n)) {
- if (pair.getValue().stringify().equals(v)) return true;
- }
- }
- return false;
- }
+ * @return for the @target annotation, this will return a set of the element-types it can be applied to. For other annotations ,
+ * it returns the empty set.
+ */
+ public Set getTargets();
+
+ /**
+ * @param name the name of the value
+ * @return true if there is a value with that name
+ */
+ public boolean hasNamedValue(String name);
+
+ /**
+ * @param name the name of the annotation field
+ * @param value the value of the annotation field
+ * @return true if there is a value with the specified name and value
+ */
+ public boolean hasNameValuePair(String name, String value);
+
+ /**
+ * @return String representation of the valid targets for this annotation, eg. "{TYPE,FIELD}"
+ */
+ public String getValidTargets();
+
+ /**
+ * @return String form of the annotation and any values, eg. @Foo(a=b,c=d)
+ */
+ public String stringify();
+
+ /**
+ * @return true if this annotation is marked with @target
+ */
+ public boolean specifiesTarget();
+
+ /**
+ * @return true if the annotation is marked for runtime visibility
+ */
+ public boolean isRuntimeVisible();
+
}
* Andy Clement initial implementation
* ******************************************************************/
-
package org.aspectj.weaver;
import java.io.DataOutputStream;
* Represents adding an annotation to a type
*/
public class AnnotationOnTypeMunger extends ResolvedTypeMunger {
- AnnotationX newAnnotation;
-
- public AnnotationOnTypeMunger(AnnotationX anno) {
- super(AnnotationOnType,null);
+ AnnotationAJ newAnnotation;
+
+ public AnnotationOnTypeMunger(AnnotationAJ anno) {
+ super(AnnotationOnType, null);
newAnnotation = anno;
}
throw new RuntimeException("unimplemented");
}
-
- public AnnotationX getNewAnnotation() {
+ public AnnotationAJ getNewAnnotation() {
return newAnnotation;
}
- public boolean equals(Object other) {
- if (!(other instanceof AnnotationOnTypeMunger)) return false;
- AnnotationOnTypeMunger o = (AnnotationOnTypeMunger)other;
- return newAnnotation.getSignature().equals(o.newAnnotation.getSignature());
- }
-
- private volatile int hashCode = 0;
- public int hashCode() {
- if (hashCode == 0) {
- int result = 17;
- result = 37*result + newAnnotation.getSignature().hashCode();
- hashCode = result;
+ public boolean equals(Object other) {
+ if (!(other instanceof AnnotationOnTypeMunger))
+ return false;
+ AnnotationOnTypeMunger o = (AnnotationOnTypeMunger) other;
+ // TODO does not check equality of annotation values
+ return newAnnotation.getTypeSignature().equals(
+ o.newAnnotation.getTypeSignature());
+ }
+
+ private volatile int hashCode = 0;
+
+ public int hashCode() {
+ if (hashCode == 0) {
+ int result = 17;
+ result = 37 * result + newAnnotation.getTypeSignature().hashCode();
+ hashCode = result;
}
- return hashCode;
- }
-
+ return hashCode;
+ }
+
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2005 IBM
- * 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 initial API and implementation
- *******************************************************************************/
-package org.aspectj.weaver;
-
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-
-import org.aspectj.apache.bcel.classfile.Utility;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.EnumElementValueGen;
-
-/**
- * AnnotationX instances are holders for an annotation from either Bcel or eclipse. We have this holder so that types about the bcel
- * weaver package can work with something not bytecode toolkit specific.
- */
-public class AnnotationX {
-
- public static final AnnotationX[] NONE = new AnnotationX[0];
-
- private AnnotationGen theRealBcelAnnotation;
- private AnnotationAJ theRealEclipseAnnotation; // OPTIMIZE push out into compiler, not ever used if purely binary weaving ?
- private int mode = -1;
- private final static int MODE_ECLIPSE = 1;
- private final static int MODE_BCEL = 2;
-
- private ResolvedType signature = null;
-
- // @target meta-annotation related stuff, built lazily
- private boolean lookedForAtTargetAnnotation = false;
- private AnnotationX atTargetAnnotation = null;
- private Set supportedTargets = null;
-
- public AnnotationX(AnnotationGen a, World world) {
- theRealBcelAnnotation = a;
- signature = UnresolvedType.forSignature(theRealBcelAnnotation.getTypeSignature()).resolve(world);
- mode = MODE_BCEL;
- }
-
- public AnnotationX(AnnotationAJ a, World world) {
- theRealEclipseAnnotation = a;
- signature = UnresolvedType.forSignature(theRealEclipseAnnotation.getTypeSignature()).resolve(world);
- mode = MODE_ECLIPSE;
- }
-
- public AnnotationGen getBcelAnnotation() {
- return theRealBcelAnnotation;
- }
-
- public UnresolvedType getSignature() {
- return signature;
- }
-
- public String toString() {
- if (mode == MODE_BCEL)
- return theRealBcelAnnotation.toString();
- else
- return theRealEclipseAnnotation.toString();
- }
-
- public String getTypeName() {
- if (mode == MODE_BCEL)
- return theRealBcelAnnotation.getTypeName();
- else
- return Utility.signatureToString(theRealEclipseAnnotation.getTypeSignature());
- }
-
- public String getTypeSignature() {
- if (mode == MODE_BCEL)
- return theRealBcelAnnotation.getTypeSignature();
- else
- return theRealEclipseAnnotation.getTypeSignature();
- }
-
- // @target related helpers
- /**
- * return true if this annotation can target an annotation type
- */
- public boolean allowedOnAnnotationType() {
- ensureAtTargetInitialized();
- if (atTargetAnnotation == null)
- return true; // if no target specified, then return true
- return supportedTargets.contains("ANNOTATION_TYPE");
- }
-
- /**
- * return true if this annotation is marked with @target()
- */
- public boolean specifiesTarget() {
- ensureAtTargetInitialized();
- return atTargetAnnotation != null;
- }
-
- /**
- * return true if this annotation can target a 'regular' type. A 'regular' type is enum/class/interface - it is *not*
- * annotation.
- */
- public boolean allowedOnRegularType() {
- ensureAtTargetInitialized();
- if (atTargetAnnotation == null)
- return true; // if no target specified, then return true
- return supportedTargets.contains("TYPE");
- }
-
- /**
- * Use in messages about this annotation
- */
- public String stringify() {
- return signature.getName();
- }
-
- public String getValidTargets() {
- StringBuffer sb = new StringBuffer();
- sb.append("{");
- for (Iterator iter = supportedTargets.iterator(); iter.hasNext();) {
- String evalue = (String) iter.next();
- sb.append(evalue);
- if (iter.hasNext())
- sb.append(",");
- }
- sb.append("}");
- return sb.toString();
- }
-
- // privates
-
- /**
- * Helper method to retrieve an annotation on an annotation e.g. retrieveAnnotationOnAnnotation(UnresolvedType.AT_TARGET)
- */
- private AnnotationX retrieveAnnotationOnAnnotation(UnresolvedType requiredAnnotationSignature) {
- AnnotationX[] annos = signature.getAnnotations();
- for (int i = 0; i < annos.length; i++) {
- AnnotationX annotationX = annos[i];
- if (annotationX.getSignature().equals(requiredAnnotationSignature))
- return annos[i];
- }
- return null;
- }
-
- /**
- * Makes sure we have looked for the @target() annotation on this annotation. Calling this method initializes (and caches) the
- * information for later use.
- */
- private void ensureAtTargetInitialized() {
- if (!lookedForAtTargetAnnotation) {
- lookedForAtTargetAnnotation = true;
- atTargetAnnotation = retrieveAnnotationOnAnnotation(UnresolvedType.AT_TARGET);
- if (atTargetAnnotation != null) {
- supportedTargets = atTargetAnnotation.getTargets();
- }
- }
- }
-
- /**
- * For the @Target annotation, this will return a set of the elementtypes it can be applied to. For non @Target annotations, it
- * returns null.
- */
- public Set /* of String */getTargets() {
- if (!signature.equals(UnresolvedType.AT_TARGET))
- return null;
- Set supportedTargets = new HashSet();
- if (mode == MODE_BCEL) {
- List values = getBcelAnnotation().getValues();
- ElementNameValuePairGen envp = (ElementNameValuePairGen) values.get(0);
- ArrayElementValueGen aev = (ArrayElementValueGen) envp.getValue();
- ElementValueGen[] evs = aev.getElementValuesArray();
- for (int i = 0; i < evs.length; i++) {
- EnumElementValueGen ev = (EnumElementValueGen) evs[i];
- supportedTargets.add(ev.getEnumValueString());
- }
- } else {
- List values = theRealEclipseAnnotation.getNameValuePairs();
- AnnotationNameValuePair nvp = (AnnotationNameValuePair) values.get(0);
- ArrayAnnotationValue aav = (ArrayAnnotationValue) nvp.getValue();
- AnnotationValue[] avs = aav.getValues();
- for (int i = 0; i < avs.length; i++) {
- AnnotationValue value = avs[i];
- supportedTargets.add(value.stringify());
- }
- }
- return supportedTargets;
- }
-
- /**
- * @return true if this annotation can be put on a field
- */
- public boolean allowedOnField() {
- ensureAtTargetInitialized();
- if (atTargetAnnotation == null)
- return true; // if no target specified, then return true
- return supportedTargets.contains("FIELD");
- }
-
- public boolean isRuntimeVisible() {
- return theRealBcelAnnotation.isRuntimeVisible();
- }
-
- public boolean hasNameValuePair(String n, String v) {
- if (mode == MODE_BCEL)
- return theRealBcelAnnotation.hasNameValuePair(n, v);
- else
- return theRealEclipseAnnotation.hasNameValuePair(n, v);
- }
-
- public boolean hasNamedValue(String n) {
- if (mode == MODE_BCEL)
- return theRealBcelAnnotation.hasNamedValue(n);
- else
- return theRealEclipseAnnotation.hasNamedValue(n);
- }
-
-}
\ No newline at end of file
import org.aspectj.weaver.patterns.PerClause;
/**
- * A BoundedReferenceType is the result of a generics wildcard expression
- * ? extends String, ? super Foo etc..
+ * A BoundedReferenceType is the result of a generics wildcard expression ?
+ * extends String, ? super Foo etc..
*
* The "signature" for a bounded reference type follows the generic signature
* specification in section 4.4 of JVM spec: *,+,- plus signature strings.
*/
public class BoundedReferenceType extends ReferenceType {
- private ResolvedType lowerBound;
+ private ResolvedType lowerBound;
- private ResolvedType upperBound;
+ private ResolvedType upperBound;
- protected ReferenceType[] additionalInterfaceBounds = new ReferenceType[0];
+ protected ReferenceType[] additionalInterfaceBounds = new ReferenceType[0];
- protected boolean isExtends = true;
+ protected boolean isExtends = true;
- protected boolean isSuper = false;
+ protected boolean isSuper = false;
- public UnresolvedType getUpperBound() {
- return upperBound;
- }
+ public UnresolvedType getUpperBound() {
+ return upperBound;
+ }
+
+ public UnresolvedType getLowerBound() {
+ return lowerBound;
+ }
- public UnresolvedType getLowerBound() {
- return lowerBound;
- }
-
- public BoundedReferenceType(ReferenceType aBound, boolean isExtends, World world) {
- super((isExtends ? "+" : "-") + aBound.signature,aBound.signatureErasure,world);
- this.isExtends = isExtends;
- this.isSuper = !isExtends;
- if (isExtends) {
+ public BoundedReferenceType(ReferenceType aBound, boolean isExtends,
+ World world) {
+ super((isExtends ? "+" : "-") + aBound.signature,
+ aBound.signatureErasure, world);
+ this.isExtends = isExtends;
+ this.isSuper = !isExtends;
+ if (isExtends) {
upperBound = aBound;
} else {
lowerBound = aBound;
- upperBound = world.resolve(UnresolvedType.OBJECT);
+ upperBound = world.resolve(UnresolvedType.OBJECT);
}
- setDelegate(new ReferenceTypeReferenceTypeDelegate((ReferenceType)getUpperBound()));
+ setDelegate(new ReferenceTypeReferenceTypeDelegate(
+ (ReferenceType) getUpperBound()));
}
-
- public BoundedReferenceType(ReferenceType aBound, boolean isExtends, World world, ReferenceType[] additionalInterfaces) {
- this(aBound,isExtends,world);
+
+ public BoundedReferenceType(ReferenceType aBound, boolean isExtends,
+ World world, ReferenceType[] additionalInterfaces) {
+ this(aBound, isExtends, world);
this.additionalInterfaceBounds = additionalInterfaces;
}
-
+
public ReferenceType[] getAdditionalBounds() {
return additionalInterfaceBounds;
}
-
+
public UnresolvedType parameterize(Map typeBindings) {
- ReferenceType[] parameterizedAdditionalInterfaces = new ReferenceType[additionalInterfaceBounds==null?0:additionalInterfaceBounds.length];
- for (int i=0; i<parameterizedAdditionalInterfaces.length;i++) {
- parameterizedAdditionalInterfaces[i] = (ReferenceType)additionalInterfaceBounds[i].parameterize(typeBindings);
+ ReferenceType[] parameterizedAdditionalInterfaces = new ReferenceType[additionalInterfaceBounds == null ? 0
+ : additionalInterfaceBounds.length];
+ for (int i = 0; i < parameterizedAdditionalInterfaces.length; i++) {
+ parameterizedAdditionalInterfaces[i] = (ReferenceType) additionalInterfaceBounds[i]
+ .parameterize(typeBindings);
}
if (isExtends) {
- return new BoundedReferenceType((ReferenceType)getUpperBound().parameterize(typeBindings),isExtends,world,parameterizedAdditionalInterfaces);
+ return new BoundedReferenceType((ReferenceType) getUpperBound()
+ .parameterize(typeBindings), isExtends, world,
+ parameterizedAdditionalInterfaces);
} else {
- return new BoundedReferenceType((ReferenceType)getLowerBound().parameterize(typeBindings),isExtends,world,parameterizedAdditionalInterfaces);
+ return new BoundedReferenceType((ReferenceType) getLowerBound()
+ .parameterize(typeBindings), isExtends, world,
+ parameterizedAdditionalInterfaces);
}
}
-
+
/**
- * only for use when resolving GenericsWildcardTypeX or a TypeVariableReferenceType
+ * only for use when resolving GenericsWildcardTypeX or a
+ * TypeVariableReferenceType
*/
protected BoundedReferenceType(String sig, String sigErasure, World world) {
super(sig, sigErasure, world);
upperBound = world.resolve(UnresolvedType.OBJECT);
- setDelegate(new ReferenceTypeReferenceTypeDelegate((ReferenceType)getUpperBound()));
+ setDelegate(new ReferenceTypeReferenceTypeDelegate(
+ (ReferenceType) getUpperBound()));
}
-
- public ReferenceType[] getInterfaceBounds() {
- return additionalInterfaceBounds;
+
+ public ReferenceType[] getInterfaceBounds() {
+ return additionalInterfaceBounds;
}
-
+
public boolean hasLowerBound() {
return getLowerBound() != null;
}
-
- public boolean isExtends() { return (isExtends && !getUpperBound().getSignature().equals("Ljava/lang/Object;")); }
- public boolean isSuper() { return isSuper; }
-
+
+ public boolean isExtends() {
+ return (isExtends && !getUpperBound().getSignature().equals(
+ "Ljava/lang/Object;"));
+ }
+
+ public boolean isSuper() {
+ return isSuper;
+ }
+
public boolean alwaysMatches(ResolvedType aCandidateType) {
if (isExtends()) {
// aCandidateType must be a subtype of upperBound
- return ((ReferenceType)getUpperBound()).isAssignableFrom(aCandidateType);
+ return ((ReferenceType) getUpperBound())
+ .isAssignableFrom(aCandidateType);
} else if (isSuper()) {
// aCandidateType must be a supertype of lowerBound
- return aCandidateType.isAssignableFrom((ReferenceType)getLowerBound());
+ return aCandidateType
+ .isAssignableFrom((ReferenceType) getLowerBound());
} else {
return true; // straight '?'
}
}
-
+
// this "maybe matches" that
public boolean canBeCoercedTo(ResolvedType aCandidateType) {
- if (alwaysMatches(aCandidateType)) return true;
+ if (alwaysMatches(aCandidateType))
+ return true;
if (aCandidateType.isGenericWildcard()) {
- BoundedReferenceType boundedRT = (BoundedReferenceType) aCandidateType;
+ BoundedReferenceType boundedRT = (BoundedReferenceType) aCandidateType;
ResolvedType myUpperBound = (ResolvedType) getUpperBound();
ResolvedType myLowerBound = (ResolvedType) getLowerBound();
if (isExtends()) {
if (boundedRT.isExtends()) {
- return myUpperBound.isAssignableFrom((ResolvedType) boundedRT.getUpperBound());
- } else if (boundedRT.isSuper()) {
- return myUpperBound == boundedRT.getLowerBound();
+ return myUpperBound
+ .isAssignableFrom((ResolvedType) boundedRT
+ .getUpperBound());
+ } else if (boundedRT.isSuper()) {
+ return myUpperBound == boundedRT.getLowerBound();
} else {
- return true; // it's '?'
+ return true; // it's '?'
}
} else if (isSuper()) {
if (boundedRT.isSuper()) {
- return ((ResolvedType) boundedRT.getLowerBound()).isAssignableFrom(myLowerBound);
- } else if (boundedRT.isExtends()) {
- return myLowerBound == boundedRT.getUpperBound();
+ return ((ResolvedType) boundedRT.getLowerBound())
+ .isAssignableFrom(myLowerBound);
+ } else if (boundedRT.isExtends()) {
+ return myLowerBound == boundedRT.getUpperBound();
} else {
return true;
}
return false;
}
}
-
+
public String getSimpleName() {
- if (!isExtends() && !isSuper()) return "?";
+ if (!isExtends() && !isSuper())
+ return "?";
if (isExtends()) {
return ("? extends " + getUpperBound().getSimpleName());
} else {
return ("? super " + getLowerBound().getSimpleName());
}
}
-
+
// override to include additional interface bounds...
public ResolvedType[] getDeclaredInterfaces() {
ResolvedType[] interfaces = super.getDeclaredInterfaces();
if (additionalInterfaceBounds.length > 0) {
- ResolvedType[] allInterfaces =
- new ResolvedType[interfaces.length + additionalInterfaceBounds.length];
- System.arraycopy(interfaces, 0, allInterfaces, 0, interfaces.length);
- System.arraycopy(additionalInterfaceBounds,0,allInterfaces,interfaces.length,additionalInterfaceBounds.length);
+ ResolvedType[] allInterfaces = new ResolvedType[interfaces.length
+ + additionalInterfaceBounds.length];
+ System
+ .arraycopy(interfaces, 0, allInterfaces, 0,
+ interfaces.length);
+ System.arraycopy(additionalInterfaceBounds, 0, allInterfaces,
+ interfaces.length, additionalInterfaceBounds.length);
return allInterfaces;
} else {
return interfaces;
}
}
-
+
public boolean isGenericWildcard() {
return true;
}
-
- protected static class ReferenceTypeReferenceTypeDelegate extends AbstractReferenceTypeDelegate {
+
+ protected static class ReferenceTypeReferenceTypeDelegate extends
+ AbstractReferenceTypeDelegate {
public ReferenceTypeReferenceTypeDelegate(ReferenceType backing) {
- super(backing,false);
+ super(backing, false);
}
-
- public void addAnnotation(AnnotationX annotationX) {
- throw new UnsupportedOperationException("What on earth do you think you are doing???");
+
+ public void addAnnotation(AnnotationAJ annotationX) {
+ throw new UnsupportedOperationException(
+ "What on earth do you think you are doing???");
}
public boolean isAspect() {
public boolean isAnnotationWithRuntimeRetention() {
return resolvedTypeX.isAnnotationWithRuntimeRetention();
}
-
+
public boolean isAnonymous() {
return resolvedTypeX.isAnonymous();
}
-
+
public boolean isNested() {
return resolvedTypeX.isNested();
}
-
+
public ResolvedType getOuterClass() {
return resolvedTypeX.getOuterClass();
}
-
+
public String getRetentionPolicy() {
return resolvedTypeX.getRetentionPolicy();
}
public boolean canAnnotationTargetType() {
return resolvedTypeX.canAnnotationTargetType();
}
-
+
public AnnotationTargetKind[] getAnnotationTargetKinds() {
return resolvedTypeX.getAnnotationTargetKinds();
}
-
+
public boolean isGeneric() {
return resolvedTypeX.isGenericType();
}
public String getDeclaredGenericSignature() {
return resolvedTypeX.getDeclaredGenericSignature();
}
-
+
public boolean hasAnnotation(UnresolvedType ofType) {
return resolvedTypeX.hasAnnotation(ofType);
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
return resolvedTypeX.getAnnotations();
}
import org.aspectj.weaver.AjAttribute.EffectiveSignatureAttribute;
/**
- * @author colyer Instances of this class are created by ResolvedMember.getSignatures() when collating all of the signatures for a
- * member. We need to create entries in the set for the "gaps" in the hierarchy. For example:
+ * @author colyer Instances of this class are created by
+ * ResolvedMember.getSignatures() when collating all of the signatures
+ * for a member. We need to create entries in the set for the "gaps" in
+ * the hierarchy. For example:
*
- * class A { void foo(); }
+ * class A { void foo(); }
*
* class B extends A {}
*
*
* has signatures:
*
- * B.foo() AND A.foo() B.foo() will be created as a ResolvedMemberWithSubstituteDeclaringType
+ * B.foo() AND A.foo() B.foo() will be created as a
+ * ResolvedMemberWithSubstituteDeclaringType
*
* Oh for a JDK 1.4 dynamic proxy.... we have to run on 1.3 :(
*/
return realMember.getAnnotationTypes();
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
return realMember.getAnnotationOfType(ofType);
}
realMember.setAnnotationTypes(annotationtypes);
}
- public void addAnnotation(AnnotationX annotation) {
+ public void addAnnotation(AnnotationAJ annotation) {
realMember.addAnnotation(annotation);
}
return realMember.getGenericParameterTypes();
}
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized) {
- return realMember.parameterizedWith(typeParameters, newDeclaringType, isParameterized);
+ return realMember.parameterizedWith(typeParameters, newDeclaringType,
+ isParameterized);
}
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized, List aliases) {
- return realMember.parameterizedWith(typeParameters, newDeclaringType, isParameterized, aliases);
+ return realMember.parameterizedWith(typeParameters, newDeclaringType,
+ isParameterized, aliases);
}
public void setTypeVariables(TypeVariable[] types) {
return realMember.getParameterTypes();
}
- public AnnotationX[][] getParameterAnnotations() {
+ public AnnotationAJ[][] getParameterAnnotations() {
return realMember.getParameterAnnotations();
}
return realMember.canBeParameterized();
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
return realMember.getAnnotations();
}
public Collection getDeclaringTypes(World world) {
- throw new UnsupportedOperationException("Adrian doesn't think you should be calling this...");
+ throw new UnsupportedOperationException(
+ "Adrian doesn't think you should be calling this...");
}
public Iterator getJoinPointSignatures(World world) {
}
public int hashCode() {
- return 17 + (37 * realMember.hashCode()) + (37 * substituteDeclaringType.hashCode());
+ return 17 + (37 * realMember.hashCode())
+ + (37 * substituteDeclaringType.hashCode());
}
public boolean hasBackingGenericMember() {
public static final Member[] NONE = new Member[0];
public static final MemberKind METHOD = new MemberKind("METHOD", 1);
public static final MemberKind FIELD = new MemberKind("FIELD", 2);
- public static final MemberKind CONSTRUCTOR = new MemberKind("CONSTRUCTOR", 3);
- public static final MemberKind STATIC_INITIALIZATION = new MemberKind("STATIC_INITIALIZATION", 4);
+ public static final MemberKind CONSTRUCTOR = new MemberKind("CONSTRUCTOR",
+ 3);
+ public static final MemberKind STATIC_INITIALIZATION = new MemberKind(
+ "STATIC_INITIALIZATION", 4);
public static final MemberKind POINTCUT = new MemberKind("POINTCUT", 5);
public static final MemberKind ADVICE = new MemberKind("ADVICE", 6);
public static final MemberKind HANDLER = new MemberKind("HANDLER", 7);
- public static final MemberKind MONITORENTER = new MemberKind("MONITORENTER", 8);
- public static final MemberKind MONITOREXIT = new MemberKind("MONITOREXIT", 9);
+ public static final MemberKind MONITORENTER = new MemberKind(
+ "MONITORENTER", 8);
+ public static final MemberKind MONITOREXIT = new MemberKind("MONITOREXIT",
+ 9);
+
+ public static final AnnotationAJ[][] NO_PARAMETER_ANNOTATIONXS = new AnnotationAJ[][] {};
+ public static final ResolvedType[][] NO_PARAMETER_ANNOTATION_TYPES = new ResolvedType[][] {};
- public static final AnnotationX[][] NO_PARAMETER_ANNOTATIONXS = new AnnotationX[][]{};
- public static final ResolvedType[][] NO_PARAMETER_ANNOTATION_TYPES = new ResolvedType[][]{};
-
public MemberKind getKind();
-
+
public ResolvedMember resolve(World world);
- public int compareTo(Object other);
+ public int compareTo(Object other);
public UnresolvedType getDeclaringType();
public UnresolvedType getReturnType();
-
+
public UnresolvedType getGenericReturnType();
-
+
public UnresolvedType[] getGenericParameterTypes();
public UnresolvedType getType();
public UnresolvedType[] getParameterTypes();
/**
- * Return full signature, including return type, e.g. "()LFastCar;". For a signature without the return type,
- * use getParameterSignature() - it is important to choose the right one in the face of covariance.
+ * Return full signature, including return type, e.g. "()LFastCar;". For a
+ * signature without the return type, use getParameterSignature() - it is
+ * important to choose the right one in the face of covariance.
*/
public String getSignature();
-
- public Iterator getJoinPointSignatures(World world);
+
+ public Iterator getJoinPointSignatures(World world);
public int getArity();
/**
- * Return signature without return type, e.g. "()" for a signature *with* the return type,
- * use getSignature() - it is important to choose the right one in the face of covariance.
+ * Return signature without return type, e.g. "()" for a signature *with*
+ * the return type, use getSignature() - it is important to choose the right
+ * one in the face of covariance.
*/
public String getParameterSignature();
public int getModifiers(World world);
-
+
public int getModifiers();
- public boolean isStatic();
+ public boolean isStatic();
- public boolean isInterface();
+ public boolean isInterface();
public boolean isPrivate();
*/
public boolean canBeParameterized();
- public AnnotationX[] getAnnotations();
-
- public Collection/* ResolvedType */getDeclaringTypes(World world);
+ public AnnotationAJ[] getAnnotations();
+
+ public Collection/* ResolvedType */getDeclaringTypes(World world);
public String[] getParameterNames(World world);
- public UnresolvedType[] getExceptions(World world);
+ public UnresolvedType[] getExceptions(World world);
}
\ No newline at end of file
private boolean reportedUnresolvableMember = false;
/**
- * All the signatures that a join point with this member as its signature has.
+ * All the signatures that a join point with this member as its signature
+ * has.
*/
private JoinPointSignatureIterator joinPointSignatures = null;
- public MemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, String name, String signature) {
+ public MemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, String name, String signature) {
this.kind = kind;
this.declaringType = declaringType;
this.modifiers = modifiers;
}
}
- public MemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, UnresolvedType returnType, String name,
+ public MemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, UnresolvedType returnType, String name,
UnresolvedType[] parameterTypes) {
this.kind = kind;
this.declaringType = declaringType;
// ---- utility methods
/**
- * returns an Object[] pair of UnresolvedType, UnresolvedType[] representing return type, argument types parsed from the JVM
- * bytecode signature of a method. Yes, this should actually return a nice statically-typed pair object, but we don't have one
- * of those.
+ * returns an Object[] pair of UnresolvedType, UnresolvedType[] representing
+ * return type, argument types parsed from the JVM bytecode signature of a
+ * method. Yes, this should actually return a nice statically-typed pair
+ * object, but we don't have one of those.
*
* <blockquote>
*
*
* </blockquote>
*
- * @param signature the JVM bytecode method signature string we want to break apart
- * @return a pair of UnresolvedType, UnresolvedType[] representing the return types and parameter types.
+ * @param signature
+ * the JVM bytecode method signature string we want to break
+ * apart
+ * @return a pair of UnresolvedType, UnresolvedType[] representing the
+ * return types and parameter types.
*/
// OPTIMIZE move static util methods out into a memberutils class
- public static String typesToSignature(UnresolvedType returnType, UnresolvedType[] paramTypes, boolean useRawTypes) {
+ public static String typesToSignature(UnresolvedType returnType,
+ UnresolvedType[] paramTypes, boolean useRawTypes) {
StringBuffer buf = new StringBuffer();
buf.append("(");
for (int i = 0, len = paramTypes.length; i < len; i++) {
}
/**
- * Returns "(<signaturesOfParamTypes>,...)" - unlike the other typesToSignature that also includes the return type, this one
- * just deals with the parameter types.
+ * Returns "(<signaturesOfParamTypes>,...)" - unlike the other
+ * typesToSignature that also includes the return type, this one just deals
+ * with the parameter types.
*/
public static String typesToSignature(UnresolvedType[] paramTypes) {
StringBuffer buf = new StringBuffer();
}
/**
- * returns an Object[] pair of UnresolvedType, UnresolvedType[] representing return type, argument types parsed from the JVM
- * bytecode signature of a method. Yes, this should actually return a nice statically-typed pair object, but we don't have one
- * of those.
+ * returns an Object[] pair of UnresolvedType, UnresolvedType[] representing
+ * return type, argument types parsed from the JVM bytecode signature of a
+ * method. Yes, this should actually return a nice statically-typed pair
+ * object, but we don't have one of those.
*
* <blockquote>
*
*
* </blockquote>
*
- * @param signature the JVM bytecode method signature string we want to break apart
- * @return a pair of UnresolvedType, UnresolvedType[] representing the return types and parameter types.
+ * @param signature
+ * the JVM bytecode method signature string we want to break
+ * apart
+ * @return a pair of UnresolvedType, UnresolvedType[] representing the
+ * return types and parameter types.
*/
- private static Object[] signatureToTypes(String sig, boolean keepParameterizationInfo) {
+ private static Object[] signatureToTypes(String sig,
+ boolean keepParameterizationInfo) {
boolean hasParameters = sig.charAt(1) != ')';
if (hasParameters) {
List l = new ArrayList();
c = sig.charAt(++i);
if (c == 'L' || c == 'P') {
int nextSemicolon = sig.indexOf(';', start);
- int firstAngly = (hasAnyAnglies ? sig.indexOf('<', start) : -1);
- if (!hasAnyAnglies || firstAngly == -1 || firstAngly > nextSemicolon) {
+ int firstAngly = (hasAnyAnglies ? sig.indexOf('<', start)
+ : -1);
+ if (!hasAnyAnglies || firstAngly == -1
+ || firstAngly > nextSemicolon) {
i = nextSemicolon + 1;
- l.add(UnresolvedType.forSignature(sig.substring(start, i)));
+ l.add(UnresolvedType.forSignature(sig.substring(start,
+ i)));
} else {
// generics generics generics
// Have to skip to the *correct* ';'
}
// posn now points to the correct nextSemicolon :)
i = posn;
- l.add(UnresolvedType.forSignature(sig.substring(start, i)));
+ l.add(UnresolvedType.forSignature(sig.substring(start,
+ i)));
}
- } else if (c == 'T') { // assumed 'reference' to a type variable, so just "Tname;"
+ } else if (c == 'T') { // assumed 'reference' to a type
+ // variable, so just "Tname;"
int nextSemicolon = sig.indexOf(';', start);
String nextbit = sig.substring(start, nextSemicolon);
l.add(UnresolvedType.forSignature(nextbit));
l.add(UnresolvedType.forSignature(sig.substring(start, i)));
}
}
- UnresolvedType[] paramTypes = (UnresolvedType[]) l.toArray(new UnresolvedType[l.size()]);
- UnresolvedType returnType = UnresolvedType.forSignature(sig.substring(i + 1, sig.length()));
+ UnresolvedType[] paramTypes = (UnresolvedType[]) l
+ .toArray(new UnresolvedType[l.size()]);
+ UnresolvedType returnType = UnresolvedType.forSignature(sig
+ .substring(i + 1, sig.length()));
return new Object[] { returnType, paramTypes };
} else {
- UnresolvedType returnType = UnresolvedType.forSignature(sig.substring(2));
+ UnresolvedType returnType = UnresolvedType.forSignature(sig
+ .substring(2));
return new Object[] { returnType, UnresolvedType.NONE };
}
}
// ---- factory methods
- public static MemberImpl field(String declaring, int mods, String name, String signature) {
- return field(declaring, mods, UnresolvedType.forSignature(signature), name);
+ public static MemberImpl field(String declaring, int mods, String name,
+ String signature) {
+ return field(declaring, mods, UnresolvedType.forSignature(signature),
+ name);
}
- // public static Member field(UnresolvedType declaring, int mods, String name, UnresolvedType type) {
- // return new MemberImpl(FIELD, declaring, mods, type, name, UnresolvedType.NONE);
+ // public static Member field(UnresolvedType declaring, int mods, String
+ // name, UnresolvedType type) {
+ // return new MemberImpl(FIELD, declaring, mods, type, name,
+ // UnresolvedType.NONE);
// }
- // OPTIMIZE do we need to call this? unless necessary the signatureToTypes() call smacks of laziness on the behalf of the caller
+ // OPTIMIZE do we need to call this? unless necessary the signatureToTypes()
+ // call smacks of laziness on the behalf of the caller
// of this method
- public static MemberImpl method(UnresolvedType declaring, int mods, String name, String signature) {
+ public static MemberImpl method(UnresolvedType declaring, int mods,
+ String name, String signature) {
Object[] pair = signatureToTypes(signature, false);
- return method(declaring, mods, (UnresolvedType) pair[0], name, (UnresolvedType[]) pair[1]);
+ return method(declaring, mods, (UnresolvedType) pair[0], name,
+ (UnresolvedType[]) pair[1]);
}
public static MemberImpl monitorEnter() {
- return new MemberImpl(MONITORENTER, UnresolvedType.OBJECT, Modifier.STATIC, ResolvedType.VOID, "<lock>",
+ return new MemberImpl(MONITORENTER, UnresolvedType.OBJECT,
+ Modifier.STATIC, ResolvedType.VOID, "<lock>",
UnresolvedType.ARRAY_WITH_JUST_OBJECT);
}
public static MemberImpl monitorExit() {
- return new MemberImpl(MONITOREXIT, UnresolvedType.OBJECT, Modifier.STATIC, ResolvedType.VOID, "<unlock>",
+ return new MemberImpl(MONITOREXIT, UnresolvedType.OBJECT,
+ Modifier.STATIC, ResolvedType.VOID, "<unlock>",
UnresolvedType.ARRAY_WITH_JUST_OBJECT);
}
- public static Member pointcut(UnresolvedType declaring, String name, String signature) {
+ public static Member pointcut(UnresolvedType declaring, String name,
+ String signature) {
Object[] pair = signatureToTypes(signature, false);
- return pointcut(declaring, 0, (UnresolvedType) pair[0], name, (UnresolvedType[]) pair[1]);
+ return pointcut(declaring, 0, (UnresolvedType) pair[0], name,
+ (UnresolvedType[]) pair[1]);
}
- private static MemberImpl field(String declaring, int mods, UnresolvedType ty, String name) {
- return new MemberImpl(FIELD, UnresolvedType.forName(declaring), mods, ty, name, UnresolvedType.NONE);
+ private static MemberImpl field(String declaring, int mods,
+ UnresolvedType ty, String name) {
+ return new MemberImpl(FIELD, UnresolvedType.forName(declaring), mods,
+ ty, name, UnresolvedType.NONE);
}
- public static MemberImpl method(UnresolvedType declTy, int mods, UnresolvedType rTy, String name, UnresolvedType[] paramTys) {
+ public static MemberImpl method(UnresolvedType declTy, int mods,
+ UnresolvedType rTy, String name, UnresolvedType[] paramTys) {
return new MemberImpl(
- // ??? this calls <clinit> a method
- name.equals("<init>") ? CONSTRUCTOR : METHOD, declTy, mods, rTy, name, paramTys);
+ // ??? this calls <clinit> a method
+ name.equals("<init>") ? CONSTRUCTOR : METHOD, declTy, mods,
+ rTy, name, paramTys);
}
- private static Member pointcut(UnresolvedType declTy, int mods, UnresolvedType rTy, String name, UnresolvedType[] paramTys) {
+ private static Member pointcut(UnresolvedType declTy, int mods,
+ UnresolvedType rTy, String name, UnresolvedType[] paramTys) {
return new MemberImpl(POINTCUT, declTy, mods, rTy, name, paramTys);
}
- public static ResolvedMemberImpl makeExceptionHandlerSignature(UnresolvedType inType, UnresolvedType catchType) {
- return new ResolvedMemberImpl(HANDLER, inType, Modifier.STATIC, "<catch>", "(" + catchType.getSignature() + ")V");
+ public static ResolvedMemberImpl makeExceptionHandlerSignature(
+ UnresolvedType inType, UnresolvedType catchType) {
+ return new ResolvedMemberImpl(HANDLER, inType, Modifier.STATIC,
+ "<catch>", "(" + catchType.getSignature() + ")V");
}
public boolean equals(Object other) {
if (!(other instanceof Member))
return false;
Member o = (Member) other;
- return (getKind() == o.getKind() && getName().equals(o.getName()) && getSignature().equals(o.getSignature()) && getDeclaringType()
+ return (getKind() == o.getKind() && getName().equals(o.getName())
+ && getSignature().equals(o.getSignature()) && getDeclaringType()
.equals(o.getDeclaringType()));
}
/**
- * Equality is checked based on the underlying signature, so the hash code of a member is based on its kind, name, signature,
- * and declaring type. The algorithm for this was taken from page 38 of effective java.
+ * Equality is checked based on the underlying signature, so the hash code
+ * of a member is based on its kind, name, signature, and declaring type.
+ * The algorithm for this was taken from page 38 of effective java.
*/
private volatile int hashCode = 0;
return paramSignature;
}
- // OPTIMIZE see next line. Why the hell are they in here if we only know it once resolution has occurred...
+ // OPTIMIZE see next line. Why the hell are they in here if we only know it
+ // once resolution has occurred...
// ---- things we know only with resolution
public int getModifiers(World world) {
return modifiers;
}
- public AnnotationX[] getAnnotations() {
- throw new UnsupportedOperationException("You should resolve this member '" + this
- + "' and call getAnnotations() on the result...");
+ public AnnotationAJ[] getAnnotations() {
+ throw new UnsupportedOperationException(
+ "You should resolve this member '" + this
+ + "' and call getAnnotations() on the result...");
}
// ---- fields 'n' stuff
ResolvedType myType = getDeclaringType().resolve(world);
Collection ret = new HashSet();
if (kind == CONSTRUCTOR) {
- // this is wrong if the member doesn't exist, but that doesn't matter
+ // this is wrong if the member doesn't exist, but that doesn't
+ // matter
ret.add(myType);
} else if (isStatic() || kind == FIELD) {
walkUpStatic(ret, myType);
}
/**
- * All the signatures that a join point with this member as its signature has.
+ * All the signatures that a join point with this member as its signature
+ * has.
*/
public Iterator getJoinPointSignatures(World inAWorld) {
if (joinPointSignatures == null) {
}
/**
- * Raises an [Xlint:cantFindType] message if the declaring type cannot be found or an [Xlint:unresolvableMember] message if the
- * type can be found (bug 149908)
+ * Raises an [Xlint:cantFindType] message if the declaring type cannot be
+ * found or an [Xlint:unresolvableMember] message if the type can be found
+ * (bug 149908)
*/
private void reportDidntFindMember(World world) {
if (reportedCantFindDeclaringType || reportedUnresolvableMember)
return;
ResolvedType rType = getDeclaringType().resolve(world);
if (rType.isMissing()) {
- world.getLint().cantFindType.signal(WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE, rType.getName()), null);
+ world.getLint().cantFindType.signal(WeaverMessages.format(
+ WeaverMessages.CANT_FIND_TYPE, rType.getName()), null);
reportedCantFindDeclaringType = true;
} else {
world.getLint().unresolvableMember.signal(getName(), null);
import org.aspectj.weaver.patterns.PerClause;
/**
- * A reference type represents some 'real' type, not a primitive, not an array - but a real type, for example java.util.List. Each
- * ReferenceType has a delegate that is the underlying artifact - either an eclipse artifact or a bcel artifact. If the type
- * represents a raw type (i.e. there is a generic form) then the genericType field is set to point to the generic type. If it is for
- * a parameterized type then the generic type is also set to point to the generic form.
+ * A reference type represents some 'real' type, not a primitive, not an array -
+ * but a real type, for example java.util.List. Each ReferenceType has a
+ * delegate that is the underlying artifact - either an eclipse artifact or a
+ * bcel artifact. If the type represents a raw type (i.e. there is a generic
+ * form) then the genericType field is set to point to the generic type. If it
+ * is for a parameterized type then the generic type is also set to point to the
+ * generic form.
*/
public class ReferenceType extends ResolvedType {
/**
- * For generic types, this list holds references to all the derived raw and parameterized versions. We need this so that if the
- * generic delegate is swapped during incremental compilation, the delegate of the derivatives is swapped also.
+ * For generic types, this list holds references to all the derived raw and
+ * parameterized versions. We need this so that if the generic delegate is
+ * swapped during incremental compilation, the delegate of the derivatives
+ * is swapped also.
*/
private List/* ReferenceType */derivativeTypes = new ArrayList();
/**
- * For parameterized types (or the raw type) - this field points to the actual reference type from which they are derived.
+ * For parameterized types (or the raw type) - this field points to the
+ * actual reference type from which they are derived.
*/
ReferenceType genericType = null;
/**
* Constructor used when creating a parameterized type.
*/
- public ReferenceType(ResolvedType theGenericType, ResolvedType[] theParameters, World aWorld) {
- super(makeParameterizedSignature(theGenericType, theParameters), theGenericType.signatureErasure, aWorld);
+ public ReferenceType(ResolvedType theGenericType,
+ ResolvedType[] theParameters, World aWorld) {
+ super(makeParameterizedSignature(theGenericType, theParameters),
+ theGenericType.signatureErasure, aWorld);
ReferenceType genericReferenceType = (ReferenceType) theGenericType;
this.typeParameters = theParameters;
this.genericType = genericReferenceType;
return (sig == null) ? "" : sig;
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
return delegate.getAnnotations();
}
- public void addAnnotation(AnnotationX annotationX) {
+ public void addAnnotation(AnnotationAJ annotationX) {
delegate.addAnnotation(annotationX);
}
return delegate.getAnnotationTypes();
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
- AnnotationX[] axs = delegate.getAnnotations();
- if (axs == null)
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
+ AnnotationAJ[] axs = delegate.getAnnotations();
+ if (axs == null) {
return null;
+ }
for (int i = 0; i < axs.length; i++) {
- if (axs[i].getSignature().equals(ofType)) {
+ if (axs[i].getTypeSignature().equals(ofType.getSignature())) {
return axs[i];
}
}
}
// ??? needs to be Methods, not just declared methods? JLS 5.5 unclear
ResolvedMember[] a = getDeclaredMethods();
- ResolvedMember[] b = other.getDeclaredMethods(); // ??? is this cast always safe
+ ResolvedMember[] b = other.getDeclaredMethods(); // ??? is this cast
+ // always safe
for (int ai = 0, alen = a.length; ai < alen; ai++) {
for (int bi = 0, blen = b.length; bi < blen; bi++) {
if (!b[bi].isCompatibleWith(a[ai]))
if (getTypeParameters().length == other.getTypeParameters().length) {
// there's a chance it can be done
ResolvedType[] myTypeParameters = getResolvedTypeParameters();
- ResolvedType[] theirTypeParameters = other.getResolvedTypeParameters();
+ ResolvedType[] theirTypeParameters = other
+ .getResolvedTypeParameters();
for (int i = 0; i < myTypeParameters.length; i++) {
if (myTypeParameters[i] != theirTypeParameters[i]) {
- // thin ice now... but List<String> may still be coerceable from e.g. List<T>
+ // thin ice now... but List<String> may still be
+ // coerceable from e.g. List<T>
if (myTypeParameters[i].isGenericWildcard()) {
BoundedReferenceType wildcard = (BoundedReferenceType) myTypeParameters[i];
- if (!wildcard.canBeCoercedTo(theirTypeParameters[i]))
+ if (!wildcard
+ .canBeCoercedTo(theirTypeParameters[i]))
return false;
- } else if (myTypeParameters[i].isTypeVariableReference()) {
+ } else if (myTypeParameters[i]
+ .isTypeVariableReference()) {
TypeVariableReferenceType tvrt = (TypeVariableReferenceType) myTypeParameters[i];
TypeVariable tv = tvrt.getTypeVariable();
tv.resolve(world);
if (!tv.canBeBoundTo(theirTypeParameters[i]))
return false;
- } else if (theirTypeParameters[i].isTypeVariableReference()) {
+ } else if (theirTypeParameters[i]
+ .isTypeVariableReference()) {
TypeVariableReferenceType tvrt = (TypeVariableReferenceType) theirTypeParameters[i];
TypeVariable tv = tvrt.getTypeVariable();
tv.resolve(world);
if (other.isPrimitiveType()) {
if (!world.isInJava5Mode())
return false;
- if (ResolvedType.validBoxing.contains(this.getSignature() + other.getSignature()))
+ if (ResolvedType.validBoxing.contains(this.getSignature()
+ + other.getSignature()))
return true;
}
if (this == other)
if (this.getSignature().equals(ResolvedType.OBJECT.getSignature()))
return true;
- if ((this.isRawType() || this.isGenericType()) && other.isParameterizedType()) {
+ if ((this.isRawType() || this.isGenericType())
+ && other.isParameterizedType()) {
if (isAssignableFrom((ResolvedType) other.getRawType()))
return true;
}
if (wildcardsAllTheWay && !other.isParameterizedType())
return true;
// we have to match by parameters one at a time
- ResolvedType[] theirParameters = other.getResolvedTypeParameters();
+ ResolvedType[] theirParameters = other
+ .getResolvedTypeParameters();
boolean parametersAssignable = true;
if (myParameters.length == theirParameters.length) {
for (int i = 0; i < myParameters.length; i++) {
if (myParameters[i] == theirParameters[i])
continue;
- if (myParameters[i].isAssignableFrom(theirParameters[i], allowMissing)) {
+ if (myParameters[i].isAssignableFrom(
+ theirParameters[i], allowMissing)) {
continue;
}
if (!myParameters[i].isGenericWildcard()) {
}
}
- if (isTypeVariableReference() && !other.isTypeVariableReference()) { // eg. this=T other=Ljava/lang/Object;
- TypeVariable aVar = ((TypeVariableReference) this).getTypeVariable();
+ if (isTypeVariableReference() && !other.isTypeVariableReference()) { // eg
+ // .
+ // this
+ // =
+ // T
+ // other
+ // =
+ // Ljava
+ // /
+ // lang
+ // /
+ // Object
+ // ;
+ TypeVariable aVar = ((TypeVariableReference) this)
+ .getTypeVariable();
return aVar.resolve(world).canBeBoundTo(other);
}
if (other.isTypeVariableReference()) {
TypeVariableReferenceType otherType = (TypeVariableReferenceType) other;
if (this instanceof TypeVariableReference) {
- return ((TypeVariableReference) this).getTypeVariable().resolve(world).canBeBoundTo(
- otherType.getTypeVariable().getFirstBound().resolve(world));// pr171952
- // return ((TypeVariableReference)this).getTypeVariable()==otherType.getTypeVariable();
+ return ((TypeVariableReference) this).getTypeVariable()
+ .resolve(world).canBeBoundTo(
+ otherType.getTypeVariable().getFirstBound()
+ .resolve(world));// pr171952
+ // return
+ // ((TypeVariableReference)this).getTypeVariable()==otherType
+ // .getTypeVariable();
} else {
// FIXME asc should this say canBeBoundTo??
- return this.isAssignableFrom(otherType.getTypeVariable().getFirstBound().resolve(world));
+ return this.isAssignableFrom(otherType.getTypeVariable()
+ .getFirstBound().resolve(world));
}
}
}
public boolean isExposedToWeaver() {
- return (delegate == null) || delegate.isExposedToWeaver(); // ??? where does this belong
+ return (delegate == null) || delegate.isExposedToWeaver(); // ??? where
+ // does this
+ // belong
}
public WeaverStateInfo getWeaverState() {
ResolvedMember[] delegateFields = delegate.getDeclaredFields();
parameterizedFields = new ResolvedMember[delegateFields.length];
for (int i = 0; i < delegateFields.length; i++) {
- parameterizedFields[i] = delegateFields[i].parameterizedWith(getTypesForMemberParameterization(), this,
+ parameterizedFields[i] = delegateFields[i].parameterizedWith(
+ getTypesForMemberParameterization(), this,
isParameterizedType());
}
return parameterizedFields;
}
/**
- * Find out from the generic signature the true signature of any interfaces I implement. If I am parameterized, these may then
- * need to be parameterized before returning.
+ * Find out from the generic signature the true signature of any interfaces
+ * I implement. If I am parameterized, these may then need to be
+ * parameterized before returning.
*/
public ResolvedType[] getDeclaredInterfaces() {
if (parameterizedInterfaces != null)
return parameterizedInterfaces;
if (isParameterizedType()) {
- ResolvedType[] delegateInterfaces = delegate.getDeclaredInterfaces();
- // UnresolvedType[] paramTypes = getTypesForMemberParameterization();
+ ResolvedType[] delegateInterfaces = delegate
+ .getDeclaredInterfaces();
+ // UnresolvedType[] paramTypes =
+ // getTypesForMemberParameterization();
parameterizedInterfaces = new ResolvedType[delegateInterfaces.length];
for (int i = 0; i < delegateInterfaces.length; i++) {
- // We may have to sub/super set the set of parametertypes if the implemented interface
+ // We may have to sub/super set the set of parametertypes if the
+ // implemented interface
// needs more or less than this type does. (pr124803/pr125080)
if (delegateInterfaces[i].isParameterizedType()) {
- parameterizedInterfaces[i] = delegateInterfaces[i].parameterize(getMemberParameterizationMap()).resolve(world);
+ parameterizedInterfaces[i] = delegateInterfaces[i]
+ .parameterize(getMemberParameterizationMap())
+ .resolve(world);
} else {
parameterizedInterfaces[i] = delegateInterfaces[i];
}
}
return parameterizedInterfaces;
} else if (isRawType()) {
- ResolvedType[] delegateInterfaces = delegate.getDeclaredInterfaces();
+ ResolvedType[] delegateInterfaces = delegate
+ .getDeclaredInterfaces();
UnresolvedType[] paramTypes = getTypesForMemberParameterization();
parameterizedInterfaces = new ResolvedType[delegateInterfaces.length];
for (int i = 0; i < parameterizedInterfaces.length; i++) {
parameterizedInterfaces[i] = delegateInterfaces[i];
if (parameterizedInterfaces[i].isGenericType()) {
- // a generic supertype of a raw type is replaced by its raw equivalent
- parameterizedInterfaces[i] = parameterizedInterfaces[i].getRawType().resolve(getWorld());
+ // a generic supertype of a raw type is replaced by its raw
+ // equivalent
+ parameterizedInterfaces[i] = parameterizedInterfaces[i]
+ .getRawType().resolve(getWorld());
} else if (parameterizedInterfaces[i].isParameterizedType()) {
- // a parameterized supertype collapses any type vars to their upper bounds
- UnresolvedType[] toUseForParameterization = determineThoseTypesToUse(parameterizedInterfaces[i], paramTypes);
- parameterizedInterfaces[i] = parameterizedInterfaces[i].parameterizedWith(toUseForParameterization);
+ // a parameterized supertype collapses any type vars to
+ // their upper bounds
+ UnresolvedType[] toUseForParameterization = determineThoseTypesToUse(
+ parameterizedInterfaces[i], paramTypes);
+ parameterizedInterfaces[i] = parameterizedInterfaces[i]
+ .parameterizedWith(toUseForParameterization);
}
}
return parameterizedInterfaces;
}
/**
- * Locates the named type variable in the list of those on this generic type and returns the type parameter from the second list
- * supplied. Returns null if it can't be found
+ * Locates the named type variable in the list of those on this generic type
+ * and returns the type parameter from the second list supplied. Returns
+ * null if it can't be found
*/
- // private UnresolvedType findTypeParameterInList(String name, TypeVariable[] tvarsOnThisGenericType, UnresolvedType[]
+ // private UnresolvedType findTypeParameterInList(String name,
+ // TypeVariable[] tvarsOnThisGenericType, UnresolvedType[]
// paramTypes) {
// int position = -1;
// for (int i = 0; i < tvarsOnThisGenericType.length; i++) {
// return paramTypes[position];
// }
/**
- * It is possible this type has multiple type variables but the interface we are about to parameterize only uses a subset - this
- * method determines the subset to use by looking at the type variable names used. For example: <code>
+ * It is possible this type has multiple type variables but the interface we
+ * are about to parameterize only uses a subset - this method determines the
+ * subset to use by looking at the type variable names used. For example:
+ * <code>
* class Foo<T extends String,E extends Number> implements SuperInterface<T> {}
* </code> where <code>
* interface SuperInterface<Z> {}
- * </code> In that
- * example, a use of the 'Foo' raw type should know that it implements the SuperInterface<String>.
+ * </code> In that example, a use of the 'Foo' raw type should
+ * know that it implements the SuperInterface<String>.
*/
- private UnresolvedType[] determineThoseTypesToUse(ResolvedType parameterizedInterface, UnresolvedType[] paramTypes) {
+ private UnresolvedType[] determineThoseTypesToUse(
+ ResolvedType parameterizedInterface, UnresolvedType[] paramTypes) {
// What are the type parameters for the supertype?
UnresolvedType[] tParms = parameterizedInterface.getTypeParameters();
UnresolvedType[] retVal = new UnresolvedType[tParms.length];
- // Go through the supertypes type parameters, if any of them is a type variable, use the
+ // Go through the supertypes type parameters, if any of them is a type
+ // variable, use the
// real type variable on the declaring type.
- // it is possibly overkill to look up the type variable - ideally the entry in the type parameter list for the
- // interface should be the a ref to the type variable in the current type ... but I'm not 100% confident right now.
+ // it is possibly overkill to look up the type variable - ideally the
+ // entry in the type parameter list for the
+ // interface should be the a ref to the type variable in the current
+ // type ... but I'm not 100% confident right now.
for (int i = 0; i < tParms.length; i++) {
UnresolvedType tParm = tParms[i];
if (tParm.isTypeVariableReference()) {
TypeVariableReference tvrt = (TypeVariableReference) tParm;
TypeVariable tv = tvrt.getTypeVariable();
int rank = getRank(tv.getName());
- // -1 probably means it is a reference to a type variable on the outer generic type (see pr129566)
+ // -1 probably means it is a reference to a type variable on the
+ // outer generic type (see pr129566)
if (rank != -1) {
retVal[i] = paramTypes[rank];
} else {
}
/**
- * Returns the position within the set of type variables for this type for the specified type variable name. Returns -1 if there
- * is no type variable with the specified name.
+ * Returns the position within the set of type variables for this type for
+ * the specified type variable name. Returns -1 if there is no type variable
+ * with the specified name.
*/
private int getRank(String tvname) {
TypeVariable[] thisTypesTVars = getGenericType().getTypeVariables();
UnresolvedType[] parameters = getTypesForMemberParameterization();
parameterizedMethods = new ResolvedMember[delegateMethods.length];
for (int i = 0; i < delegateMethods.length; i++) {
- parameterizedMethods[i] = delegateMethods[i].parameterizedWith(parameters, this, isParameterizedType());
+ parameterizedMethods[i] = delegateMethods[i].parameterizedWith(
+ parameters, this, isParameterizedType());
}
return parameterizedMethods;
} else {
if (parameterizedPointcuts != null)
return parameterizedPointcuts;
if (isParameterizedType()) {
- ResolvedMember[] delegatePointcuts = delegate.getDeclaredPointcuts();
+ ResolvedMember[] delegatePointcuts = delegate
+ .getDeclaredPointcuts();
parameterizedPointcuts = new ResolvedMember[delegatePointcuts.length];
for (int i = 0; i < delegatePointcuts.length; i++) {
- parameterizedPointcuts[i] = delegatePointcuts[i].parameterizedWith(getTypesForMemberParameterization(), this,
- isParameterizedType());
+ parameterizedPointcuts[i] = delegatePointcuts[i]
+ .parameterizedWith(getTypesForMemberParameterization(),
+ this, isParameterizedType());
}
return parameterizedPointcuts;
} else {
PerClause pclause = delegate.getPerClause();
if (isParameterizedType()) { // could cache the result here...
Map parameterizationMap = getAjMemberParameterizationMap();
- pclause = (PerClause) pclause.parameterizeWith(parameterizationMap, world);
+ pclause = (PerClause) pclause.parameterizeWith(parameterizationMap,
+ world);
}
return pclause;
}
Map parameterizationMap = getAjMemberParameterizationMap();
for (Iterator iter = genericDeclares.iterator(); iter.hasNext();) {
Declare declareStatement = (Declare) iter.next();
- parameterizedDeclares.add(declareStatement.parameterizeWith(parameterizationMap, world));
+ parameterizedDeclares.add(declareStatement.parameterizeWith(
+ parameterizationMap, world));
}
declares = parameterizedDeclares;
} else {
// Map parameterizationMap = getAjMemberParameterizationMap();
// for (Iterator iter = genericDeclares.iterator(); iter.hasNext();) {
// ConcreteTypeMunger munger = (ConcreteTypeMunger)iter.next();
- // parameterizedTypeMungers.add(munger.parameterizeWith(parameterizationMap,world));
+ // parameterizedTypeMungers.add(munger.parameterizeWith(parameterizationMap,
+ // world));
// }
// ret = parameterizedTypeMungers;
// } else {
world.setTypeVariableLookupScope(null);
}
if (this.isParameterizedType() && ret.isParameterizedType()) {
- ret = ret.parameterize(getMemberParameterizationMap()).resolve(getWorld());
+ ret = ret.parameterize(getMemberParameterizationMap()).resolve(
+ getWorld());
}
return ret;
}
}
public void setDelegate(ReferenceTypeDelegate delegate) {
- // Don't copy from BcelObjectType to EclipseSourceType - the context may be tidied (result null'd) after previous weaving
- if (this.delegate != null && !(this.delegate instanceof BcelObjectType)
+ // Don't copy from BcelObjectType to EclipseSourceType - the context may
+ // be tidied (result null'd) after previous weaving
+ if (this.delegate != null
+ && !(this.delegate instanceof BcelObjectType)
&& this.delegate.getSourceContext() != SourceContextImpl.UNKNOWN_SOURCE_CONTEXT)
- ((AbstractReferenceTypeDelegate) delegate).setSourceContext(this.delegate.getSourceContext());
+ ((AbstractReferenceTypeDelegate) delegate)
+ .setSourceContext(this.delegate.getSourceContext());
this.delegate = delegate;
for (Iterator it = this.derivativeTypes.iterator(); it.hasNext();) {
ReferenceType dependent = (ReferenceType) it.next();
}
/**
- * a parameterized signature starts with a "P" in place of the "L", see the comment on signatures in UnresolvedType.
+ * a parameterized signature starts with a "P" in place of the "L", see the
+ * comment on signatures in UnresolvedType.
*
* @param aGenericType
* @param someParameters
* @return
*/
- private static String makeParameterizedSignature(ResolvedType aGenericType, ResolvedType[] someParameters) {
+ private static String makeParameterizedSignature(ResolvedType aGenericType,
+ ResolvedType[] someParameters) {
String rawSignature = aGenericType.getErasureSignature();
StringBuffer ret = new StringBuffer();
ret.append(PARAMETERIZED_TYPE_IDENTIFIER);
return ret.toString();
}
- private static String makeDeclaredSignature(ResolvedType aGenericType, UnresolvedType[] someParameters) {
+ private static String makeDeclaredSignature(ResolvedType aGenericType,
+ UnresolvedType[] someParameters) {
StringBuffer ret = new StringBuffer();
String rawSig = aGenericType.getErasureSignature();
ret.append(rawSig.substring(0, rawSig.length() - 1));
ret.append("<");
for (int i = 0; i < someParameters.length; i++) {
- ret.append(((ReferenceType) someParameters[i]).getSignatureForAttribute());
+ ret.append(((ReferenceType) someParameters[i])
+ .getSignatureForAttribute());
}
ret.append(">;");
return ret.toString();
import org.aspectj.weaver.patterns.PerClause;
/**
- * Abstraction over a type - a reference type is Object and a descendant of Object, other types (int/etc) are
- * considered primitive types. Abstract implementation provided by AbstractReferenceTypeDelegate.
+ * Abstraction over a type - a reference type is Object and a descendant of
+ * Object, other types (int/etc) are considered primitive types. Abstract
+ * implementation provided by AbstractReferenceTypeDelegate.
*/
public interface ReferenceTypeDelegate {
-
+
// TODO asc move to proxy
- public void addAnnotation(AnnotationX annotationX);
- public void ensureDelegateConsistent(); // Required evil because of mutator methods in delegates :( (see pr85132)
-
+ public void addAnnotation(AnnotationAJ annotationX);
+
+ public void ensureDelegateConsistent(); // Required evil because of mutator
+
+ // methods in delegates :( (see
+ // pr85132)
+
public boolean isAspect();
- public boolean isAnnotationStyleAspect();
- public boolean isInterface();
- public boolean isEnum();
- public boolean isAnnotation();
- public String getRetentionPolicy();
- public boolean canAnnotationTargetType();
- public AnnotationTargetKind[] getAnnotationTargetKinds();
- public boolean isAnnotationWithRuntimeRetention();
+
+ public boolean isAnnotationStyleAspect();
+
+ public boolean isInterface();
+
+ public boolean isEnum();
+
+ public boolean isAnnotation();
+
+ public String getRetentionPolicy();
+
+ public boolean canAnnotationTargetType();
+
+ public AnnotationTargetKind[] getAnnotationTargetKinds();
+
+ public boolean isAnnotationWithRuntimeRetention();
+
public boolean isClass();
+
public boolean isGeneric();
+
public boolean isAnonymous();
+
public boolean isNested();
+
public boolean isExposedToWeaver();
-
+
public boolean hasAnnotation(UnresolvedType ofType);
-
- public AnnotationX[] getAnnotations();
- public ResolvedType[] getAnnotationTypes();
+
+ public AnnotationAJ[] getAnnotations();
+
+ public ResolvedType[] getAnnotationTypes();
+
public ResolvedMember[] getDeclaredFields();
- public ResolvedType[] getDeclaredInterfaces();
+
+ public ResolvedType[] getDeclaredInterfaces();
+
public ResolvedMember[] getDeclaredMethods();
+
public ResolvedMember[] getDeclaredPointcuts();
+
public TypeVariable[] getTypeVariables();
- public PerClause getPerClause();
- public Collection getDeclares() ;
+ public PerClause getPerClause();
+
+ public Collection getDeclares();
+
public Collection getTypeMungers();
+
public Collection getPrivilegedAccesses();
+
public int getModifiers();
- public ResolvedType getSuperclass();
+
+ public ResolvedType getSuperclass();
+
public WeaverStateInfo getWeaverState();
+
public ReferenceType getResolvedTypeX();
+
public boolean doesNotExposeShadowMungers();
-
+
public ISourceContext getSourceContext();
-
+
public String getSourcefilename();
-
+
public String getDeclaredGenericSignature();
+
public ResolvedType getOuterClass();
-
+
}
\ No newline at end of file
import org.aspectj.bridge.ISourceLocation;
-public interface ResolvedMember extends Member, AnnotatedElement, TypeVariableDeclaringElement {
+public interface ResolvedMember extends Member, AnnotatedElement,
+ TypeVariableDeclaringElement {
public static final ResolvedMember[] NONE = new ResolvedMember[0];
public boolean hasAnnotation(UnresolvedType ofType);
- public AnnotationX[] getAnnotations();
+ public AnnotationAJ[] getAnnotations();
public ResolvedType[] getAnnotationTypes();
public void setAnnotationTypes(UnresolvedType[] annotationtypes);
- public void addAnnotation(AnnotationX annotation);
+ public void addAnnotation(AnnotationAJ annotation);
public boolean isBridgeMethod();
public void setParameterNames(String[] names);
- public AnnotationX[][] getParameterAnnotations();
+ public AnnotationAJ[][] getParameterAnnotations();
public ResolvedType[][] getParameterAnnotationTypes();
public ResolvedMember getBackingGenericMember();
/**
- * Get the UnresolvedType for the return type, taking generic signature into account
+ * Get the UnresolvedType for the return type, taking generic signature into
+ * account
*/
public UnresolvedType getGenericReturnType();
/**
- * Get the TypeXs of the parameter types, taking generic signature into account
+ * Get the TypeXs of the parameter types, taking generic signature into
+ * account
*/
public UnresolvedType[] getGenericParameterTypes();
- // return a resolved member in which all type variables in the signature of this
+ // return a resolved member in which all type variables in the signature of
+ // this
// member have been replaced with the given bindings.
- // the isParameterized flag tells us whether we are creating a raw type version or not
+ // the isParameterized flag tells us whether we are creating a raw type
+ // version or not
// if isParameterized List<T> will turn into List<String> (for example),
// but if !isParameterized List<T> will turn into List.
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized);
- // this variant allows for aliases for type variables (i.e. allowing them to have another name)
- // this is used for processing ITDs that share type variables with their target generic type
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ // this variant allows for aliases for type variables (i.e. allowing them to
+ // have another name)
+ // this is used for processing ITDs that share type variables with their
+ // target generic type
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized, List aliases);
public void setTypeVariables(TypeVariable[] types);
public TypeVariable[] getTypeVariables();
// /**
- // * If this member is defined by a parameterized super-type, return the erasure
+ // * If this member is defined by a parameterized super-type, return the
+ // erasure
// * of that member.
// * For example:
// * interface I<T> { T foo(T aTea); }
// public ResolvedMember getErasure();
/**
- * Returns true if this member matches the other. The matching takes into account name and parameter types only. When comparing
- * parameter types, we allow any type variable to match any other type variable regardless of bounds.
+ * Returns true if this member matches the other. The matching takes into
+ * account name and parameter types only. When comparing parameter types, we
+ * allow any type variable to match any other type variable regardless of
+ * bounds.
*/
public boolean matches(ResolvedMember aCandidateMatch);
import org.aspectj.bridge.ISourceLocation;
/**
- * This is the declared member, i.e. it will always correspond to an actual method/... declaration
+ * This is the declared member, i.e. it will always correspond to an actual
+ * method/... declaration
*/
-public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, AnnotatedElement, TypeVariableDeclaringElement,
- ResolvedMember {
+public class ResolvedMemberImpl extends MemberImpl implements IHasPosition,
+ AnnotatedElement, TypeVariableDeclaringElement, ResolvedMember {
private String[] parameterNames = null;
protected UnresolvedType[] checkedExceptions = UnresolvedType.NONE;
/**
- * if this member is a parameterized version of a member in a generic type, then this field holds a reference to the member we
- * parameterize.
+ * if this member is a parameterized version of a member in a generic type,
+ * then this field holds a reference to the member we parameterize.
*/
protected ResolvedMember backingGenericMember = null;
protected Set annotationTypes = null;
protected ResolvedType[][] parameterAnnotationTypes = null;
- // Some members are 'created' to represent other things (for example ITDs). These
- // members have their annotations stored elsewhere, and this flag indicates that is
+ // Some members are 'created' to represent other things (for example ITDs).
+ // These
+ // members have their annotations stored elsewhere, and this flag indicates
+ // that is
// the case. It is up to the caller to work out where that is!
- // Once determined the caller may choose to stash the annotations in this member...
- private boolean isAnnotatedElsewhere = false; // this field is not serialized.
+ // Once determined the caller may choose to stash the annotations in this
+ // member...
+ private boolean isAnnotatedElsewhere = false; // this field is not
+ // serialized.
private boolean isAjSynthetic = false;
// generic methods have type variables
protected ISourceContext sourceContext = null;
// XXX deprecate this in favor of the constructor below
- public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, UnresolvedType returnType, String name,
+ public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, UnresolvedType returnType, String name,
UnresolvedType[] parameterTypes) {
super(kind, declaringType, modifiers, returnType, name, parameterTypes);
}
- public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, UnresolvedType returnType, String name,
+ public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, UnresolvedType returnType, String name,
UnresolvedType[] parameterTypes, UnresolvedType[] checkedExceptions) {
super(kind, declaringType, modifiers, returnType, name, parameterTypes);
this.checkedExceptions = checkedExceptions;
}
- public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, UnresolvedType returnType, String name,
- UnresolvedType[] parameterTypes, UnresolvedType[] checkedExceptions, ResolvedMember backingGenericMember) {
- this(kind, declaringType, modifiers, returnType, name, parameterTypes, checkedExceptions);
+ public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, UnresolvedType returnType, String name,
+ UnresolvedType[] parameterTypes,
+ UnresolvedType[] checkedExceptions,
+ ResolvedMember backingGenericMember) {
+ this(kind, declaringType, modifiers, returnType, name, parameterTypes,
+ checkedExceptions);
this.backingGenericMember = backingGenericMember;
this.isAjSynthetic = backingGenericMember.isAjSynthetic();
}
- public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, String name, String signature) {
+ public ResolvedMemberImpl(MemberKind kind, UnresolvedType declaringType,
+ int modifiers, String name, String signature) {
super(kind, declaringType, modifiers, name, signature);
}
/**
- * Compute the full set of signatures for a member. This walks up the hierarchy giving the ResolvedMember in each defining type
- * in the hierarchy. A shadowMember can be created with a target type (declaring type) that does not actually define the member.
- * This is ok as long as the member is inherited in the declaring type. Each declaring type in the line to the actual declaring
- * type is added as an additional signature. For example:
+ * Compute the full set of signatures for a member. This walks up the
+ * hierarchy giving the ResolvedMember in each defining type in the
+ * hierarchy. A shadowMember can be created with a target type (declaring
+ * type) that does not actually define the member. This is ok as long as the
+ * member is inherited in the declaring type. Each declaring type in the
+ * line to the actual declaring type is added as an additional signature.
+ * For example:
*
* class A { void foo(); } class B extends A {}
*
* @param joinPointSignature
* @param inAWorld
*/
- public static JoinPointSignature[] getJoinPointSignatures(Member joinPointSignature, World inAWorld) {
+ public static JoinPointSignature[] getJoinPointSignatures(
+ Member joinPointSignature, World inAWorld) {
- // Walk up hierarchy creating one member for each type up to and including the
+ // Walk up hierarchy creating one member for each type up to and
+ // including the
// first defining type
- ResolvedType originalDeclaringType = joinPointSignature.getDeclaringType().resolve(inAWorld);
- ResolvedMemberImpl firstDefiningMember = (ResolvedMemberImpl) joinPointSignature.resolve(inAWorld);
+ ResolvedType originalDeclaringType = joinPointSignature
+ .getDeclaringType().resolve(inAWorld);
+ ResolvedMemberImpl firstDefiningMember = (ResolvedMemberImpl) joinPointSignature
+ .resolve(inAWorld);
if (firstDefiningMember == null) {
return new JoinPointSignature[0];
}
- // declaringType can be unresolved if we matched a synthetic member generated by Aj...
- // should be fixed elsewhere but add this resolve call on the end for now so that we can
+ // declaringType can be unresolved if we matched a synthetic member
+ // generated by Aj...
+ // should be fixed elsewhere but add this resolve call on the end for
+ // now so that we can
// focus on one problem at a time...
- ResolvedType firstDefiningType = firstDefiningMember.getDeclaringType().resolve(inAWorld);
+ ResolvedType firstDefiningType = firstDefiningMember.getDeclaringType()
+ .resolve(inAWorld);
if (firstDefiningType != originalDeclaringType) {
if (joinPointSignature.getKind() == Member.CONSTRUCTOR) {
return new JoinPointSignature[0];
}
List declaringTypes = new ArrayList();
- accumulateTypesInBetween(originalDeclaringType, firstDefiningType, declaringTypes);
+ accumulateTypesInBetween(originalDeclaringType, firstDefiningType,
+ declaringTypes);
Set memberSignatures = new HashSet();
for (Iterator iter = declaringTypes.iterator(); iter.hasNext();) {
ResolvedType declaringType = (ResolvedType) iter.next();
- ResolvedMember member = firstDefiningMember.withSubstituteDeclaringType(declaringType);
+ ResolvedMember member = firstDefiningMember
+ .withSubstituteDeclaringType(declaringType);
memberSignatures.add(member);
}
if (shouldWalkUpHierarchyFor(firstDefiningMember)) {
- // now walk up the hierarchy from the firstDefiningMember and include the signature for
- // every type between the firstDefiningMember and the root defining member.
- Iterator superTypeIterator = firstDefiningType.getDirectSupertypes();
+ // now walk up the hierarchy from the firstDefiningMember and
+ // include the signature for
+ // every type between the firstDefiningMember and the root defining
+ // member.
+ Iterator superTypeIterator = firstDefiningType
+ .getDirectSupertypes();
List typesAlreadyVisited = new ArrayList();
- accumulateMembersMatching(firstDefiningMember, superTypeIterator, typesAlreadyVisited, memberSignatures);
+ accumulateMembersMatching(firstDefiningMember, superTypeIterator,
+ typesAlreadyVisited, memberSignatures);
}
- JoinPointSignature[] ret = new JoinPointSignature[memberSignatures.size()];
+ JoinPointSignature[] ret = new JoinPointSignature[memberSignatures
+ .size()];
memberSignatures.toArray(ret);
return ret;
}
}
/**
- * Build a list containing every type between subtype and supertype, inclusively.
+ * Build a list containing every type between subtype and supertype,
+ * inclusively.
*/
- private static void accumulateTypesInBetween(ResolvedType subType, ResolvedType superType, List types) {
+ private static void accumulateTypesInBetween(ResolvedType subType,
+ ResolvedType superType, List types) {
types.add(subType);
if (subType == superType) {
return;
}
/**
- * We have a resolved member, possibly with type parameter references as parameters or return type. We need to find all its
- * ancestor members. When doing this, a type parameter matches regardless of bounds (bounds can be narrowed down the hierarchy).
+ * We have a resolved member, possibly with type parameter references as
+ * parameters or return type. We need to find all its ancestor members. When
+ * doing this, a type parameter matches regardless of bounds (bounds can be
+ * narrowed down the hierarchy).
*/
- private static void accumulateMembersMatching(ResolvedMemberImpl memberToMatch, Iterator typesToLookIn,
+ private static void accumulateMembersMatching(
+ ResolvedMemberImpl memberToMatch, Iterator typesToLookIn,
List typesAlreadyVisited, Set foundMembers) {
while (typesToLookIn.hasNext()) {
ResolvedType toLookIn = (ResolvedType) typesToLookIn.next();
if (!typesAlreadyVisited.contains(toLookIn)) {
typesAlreadyVisited.add(toLookIn);
- ResolvedMemberImpl foundMember = (ResolvedMemberImpl) toLookIn.lookupResolvedMember(memberToMatch, true);
- if (foundMember != null && isVisibleTo(memberToMatch, foundMember)) {
+ ResolvedMemberImpl foundMember = (ResolvedMemberImpl) toLookIn
+ .lookupResolvedMember(memberToMatch, true);
+ if (foundMember != null
+ && isVisibleTo(memberToMatch, foundMember)) {
List declaringTypes = new ArrayList();
- // declaring type can be unresolved if the member can from an ITD...
- ResolvedType resolvedDeclaringType = foundMember.getDeclaringType().resolve(toLookIn.getWorld());
- accumulateTypesInBetween(toLookIn, resolvedDeclaringType, declaringTypes);
- for (Iterator iter = declaringTypes.iterator(); iter.hasNext();) {
+ // declaring type can be unresolved if the member can from
+ // an ITD...
+ ResolvedType resolvedDeclaringType = foundMember
+ .getDeclaringType().resolve(toLookIn.getWorld());
+ accumulateTypesInBetween(toLookIn, resolvedDeclaringType,
+ declaringTypes);
+ for (Iterator iter = declaringTypes.iterator(); iter
+ .hasNext();) {
ResolvedType declaringType = (ResolvedType) iter.next();
// typesAlreadyVisited.add(declaringType);
- ResolvedMember member = foundMember.withSubstituteDeclaringType(declaringType);
+ ResolvedMember member = foundMember
+ .withSubstituteDeclaringType(declaringType);
foundMembers.add(member);
}
- if (toLookIn.isParameterizedType() && (foundMember.backingGenericMember != null)) {
- foundMembers.add(new JoinPointSignature(foundMember.backingGenericMember, foundMember.declaringType
- .resolve(toLookIn.getWorld())));
+ if (toLookIn.isParameterizedType()
+ && (foundMember.backingGenericMember != null)) {
+ foundMembers.add(new JoinPointSignature(
+ foundMember.backingGenericMember,
+ foundMember.declaringType.resolve(toLookIn
+ .getWorld())));
}
- accumulateMembersMatching(foundMember, toLookIn.getDirectSupertypes(), typesAlreadyVisited, foundMembers);
- // if this was a parameterized type, look in the generic type that backs it too
+ accumulateMembersMatching(foundMember, toLookIn
+ .getDirectSupertypes(), typesAlreadyVisited,
+ foundMembers);
+ // if this was a parameterized type, look in the generic
+ // type that backs it too
}
}
}
}
/**
- * Returns true if the parent member is visible to the child member In the same declaring type this is always true, otherwise if
- * parent is private it is false.
+ * Returns true if the parent member is visible to the child member In the
+ * same declaring type this is always true, otherwise if parent is private
+ * it is false.
*
* @param childMember
* @param parentMember
* @return
*/
- private static boolean isVisibleTo(ResolvedMember childMember, ResolvedMember parentMember) {
- if (childMember.getDeclaringType().equals(parentMember.getDeclaringType()))
+ private static boolean isVisibleTo(ResolvedMember childMember,
+ ResolvedMember parentMember) {
+ if (childMember.getDeclaringType().equals(
+ parentMember.getDeclaringType()))
return true;
if (Modifier.isPrivate(parentMember.getModifiers())) {
return false;
}
/**
- * Check if this member has an annotation of the specified type. If the member has a backing generic member then this member
- * represents a parameterization of a member in a generic type and the annotations available on the backing generic member
- * should be used.
+ * Check if this member has an annotation of the specified type. If the
+ * member has a backing generic member then this member represents a
+ * parameterization of a member in a generic type and the annotations
+ * available on the backing generic member should be used.
*
- * @param ofType the type of the annotation being searched for
- * @return true if the annotation is found on this member or its backing generic member
+ * @param ofType
+ * the type of the annotation being searched for
+ * @return true if the annotation is found on this member or its backing
+ * generic member
*/
public boolean hasAnnotation(UnresolvedType ofType) {
// The ctors don't allow annotations to be specified ... yet - but
// this type - BcelField/BcelMethod
if (backingGenericMember != null) {
if (annotationTypes != null) {
- throw new BCException("Unexpectedly found a backing generic member and a local set of annotations");
+ throw new BCException(
+ "Unexpectedly found a backing generic member and a local set of annotations");
}
return backingGenericMember.hasAnnotation(ofType);
}
// this type - BcelField/BcelMethod
if (backingGenericMember != null) {
if (annotationTypes != null) {
- throw new BCException("Unexpectedly found a backing generic member and a local set of annotations");
+ throw new BCException(
+ "Unexpectedly found a backing generic member and a local set of annotations");
}
return backingGenericMember.getAnnotationTypes();
}
"You should resolve this member and call getAnnotationDefaultValue() on the result...");
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
if (backingGenericMember != null)
return backingGenericMember.getAnnotations();
return super.getAnnotations();
return parameterAnnotationTypes;
}
- public AnnotationX[][] getParameterAnnotations() {
+ public AnnotationAJ[][] getParameterAnnotations() {
if (backingGenericMember != null)
return backingGenericMember.getParameterAnnotations();
- throw new BCException("Cannot return parameter annotations for a " + this.getClass().getName() + " member");
+ throw new BCException("Cannot return parameter annotations for a "
+ + this.getClass().getName() + " member");
// return super.getParameterAnnotations();
}
- public void addAnnotation(AnnotationX annotation) {
- // FIXME asc only allows for annotation types, not instances - should it?
+ public void addAnnotation(AnnotationAJ annotation) {
+ // FIXME asc only allows for annotation types, not instances - should
+ // it?
if (annotationTypes == null)
annotationTypes = new HashSet();
- annotationTypes.add(annotation.getSignature());
+ annotationTypes.add(annotation.getType());
}
public boolean isBridgeMethod() {
- return (modifiers & Constants.ACC_BRIDGE) != 0 && getKind().equals(METHOD);
+ return (modifiers & Constants.ACC_BRIDGE) != 0
+ && getKind().equals(METHOD);
}
public boolean isVarargsMethod() {
}
public boolean isSynthetic() {
- // See Bcelmethod.isSynthetic() which takes account of preJava5 Synthetic modifier
+ // See Bcelmethod.isSynthetic() which takes account of preJava5
+ // Synthetic modifier
return (modifiers & 4096) != 0; // do we know better?
}
}
/**
- * Return the member generic signature that would be suitable for inclusion in a class file Signature attribute. For: <T>
- * List<String> getThem(T t) {} we would create: <T:Ljava/lang/Object;>(TT;)Ljava/util/List<Ljava/lang/String;>;;
+ * Return the member generic signature that would be suitable for inclusion
+ * in a class file Signature attribute. For: <T> List<String> getThem(T t)
+ * {} we would create:
+ * <T:Ljava/lang/Object;>(TT;)Ljava/util/List<Ljava/lang/String;>;;
*
- * @return the generic signature for the member that could be inserted into a class file
+ * @return the generic signature for the member that could be inserted into
+ * a class file
*/
public String getSignatureForAttribute() {
StringBuffer sb = new StringBuffer();
if (typeVariables != null) {
sb.append("<");
for (int i = 0; i < typeVariables.length; i++) {
- sb.append(typeVariables[i].getSignatureForAttribute()); // need a 'getSignatureForAttribute()'
+ sb.append(typeVariables[i].getSignatureForAttribute()); // need
+ // a
+ // 'getSignatureForAttribute()'
}
sb.append(">");
}
return sb.toString();
}
- public static void writeArray(ResolvedMember[] members, DataOutputStream s) throws IOException {
+ public static void writeArray(ResolvedMember[] members, DataOutputStream s)
+ throws IOException {
s.writeInt(members.length);
for (int i = 0, len = members.length; i < len; i++) {
members[i].write(s);
}
}
- public static ResolvedMemberImpl readResolvedMember(VersionedDataInputStream s, ISourceContext sourceContext)
+ public static ResolvedMemberImpl readResolvedMember(
+ VersionedDataInputStream s, ISourceContext sourceContext)
throws IOException {
- ResolvedMemberImpl m = new ResolvedMemberImpl(MemberKind.read(s), UnresolvedType.read(s), s.readInt(), s.readUTF(), s
- .readUTF());
+ ResolvedMemberImpl m = new ResolvedMemberImpl(MemberKind.read(s),
+ UnresolvedType.read(s), s.readInt(), s.readUTF(), s.readUTF());
m.checkedExceptions = UnresolvedType.readArray(s);
m.start = s.readInt();
int ps = s.readInt();
UnresolvedType[] params = new UnresolvedType[ps];
for (int i = 0; i < params.length; i++) {
- params[i] = TypeFactory.createTypeFromSignature(s.readUTF());
+ params[i] = TypeFactory.createTypeFromSignature(s
+ .readUTF());
}
- UnresolvedType rt = TypeFactory.createTypeFromSignature(s.readUTF());
+ UnresolvedType rt = TypeFactory.createTypeFromSignature(s
+ .readUTF());
m.parameterTypes = params;
m.returnType = rt;
}
return m;
}
- public static ResolvedMember[] readResolvedMemberArray(VersionedDataInputStream s, ISourceContext context) throws IOException {
+ public static ResolvedMember[] readResolvedMemberArray(
+ VersionedDataInputStream s, ISourceContext context)
+ throws IOException {
int len = s.readInt();
ResolvedMember[] members = new ResolvedMember[len];
for (int i = 0; i < len; i++) {
return members;
}
- // OPTIMIZE dont like how resolve(world) on ResolvedMemberImpl does something different to world.resolve(member)
+ // OPTIMIZE dont like how resolve(world) on ResolvedMemberImpl does
+ // something different to world.resolve(member)
public ResolvedMember resolve(World world) {
// make sure all the pieces of a resolvedmember really are resolved
try {
}
declaringType = declaringType.resolve(world);
if (declaringType.isRawType())
- declaringType = ((ReferenceType) declaringType).getGenericType();
+ declaringType = ((ReferenceType) declaringType)
+ .getGenericType();
if (parameterTypes != null && parameterTypes.length > 0) {
for (int i = 0; i < parameterTypes.length; i++) {
public boolean isVisible(ResolvedType fromType) {
World world = fromType.getWorld();
- return ResolvedType.isVisible(getModifiers(), getDeclaringType().resolve(world), fromType);
+ return ResolvedType.isVisible(getModifiers(), getDeclaringType()
+ .resolve(world), fromType);
}
public void setCheckedExceptions(UnresolvedType[] checkedExceptions) {
}
/**
- * Get the UnresolvedType for the return type, taking generic signature into account
+ * Get the UnresolvedType for the return type, taking generic signature into
+ * account
*/
public UnresolvedType getGenericReturnType() {
return getReturnType();
}
/**
- * Get the TypeXs of the parameter types, taking generic signature into account
+ * Get the TypeXs of the parameter types, taking generic signature into
+ * account
*/
public UnresolvedType[] getGenericParameterTypes() {
return getParameterTypes();
}
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized) {
- return parameterizedWith(typeParameters, newDeclaringType, isParameterized, null);
+ return parameterizedWith(typeParameters, newDeclaringType,
+ isParameterized, null);
}
/**
- * Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings. The
- * 'isParameterized' flag tells us whether we are creating a raw type version or not. if (isParameterized) then List<T> will
- * turn into List<String> (for example) - if (!isParameterized) then List<T> will turn into List.
+ * Return a resolvedmember in which all the type variables in the signature
+ * have been replaced with the given bindings. The 'isParameterized' flag
+ * tells us whether we are creating a raw type version or not. if
+ * (isParameterized) then List<T> will turn into List<String> (for example)
+ * - if (!isParameterized) then List<T> will turn into List.
*/
- public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
+ public ResolvedMemberImpl parameterizedWith(
+ UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
boolean isParameterized, List aliases) {
if (// isParameterized && <-- might need this bit...
!getDeclaringType().isGenericType()) {
- throw new IllegalStateException("Can't ask to parameterize a member of non-generic type: " + getDeclaringType()
- + " kind(" + getDeclaringType().typeKind + ")");
+ throw new IllegalStateException(
+ "Can't ask to parameterize a member of non-generic type: "
+ + getDeclaringType() + " kind("
+ + getDeclaringType().typeKind + ")");
}
TypeVariable[] typeVariables = getDeclaringType().getTypeVariables();
if (isParameterized && (typeVariables.length != typeParameters.length)) {
- throw new IllegalStateException("Wrong number of type parameters supplied");
+ throw new IllegalStateException(
+ "Wrong number of type parameters supplied");
}
Map typeMap = new HashMap();
- boolean typeParametersSupplied = typeParameters != null && typeParameters.length > 0;
+ boolean typeParametersSupplied = typeParameters != null
+ && typeParameters.length > 0;
if (typeVariables != null) {
- // If no 'replacements' were supplied in the typeParameters array then collapse
+ // If no 'replacements' were supplied in the typeParameters array
+ // then collapse
// type variables to their first bound.
for (int i = 0; i < typeVariables.length; i++) {
- UnresolvedType ut = (!typeParametersSupplied ? typeVariables[i].getFirstBound() : typeParameters[i]);
+ UnresolvedType ut = (!typeParametersSupplied ? typeVariables[i]
+ .getFirstBound() : typeParameters[i]);
typeMap.put(typeVariables[i].getName(), ut);
}
}
- // For ITDs on generic types that use type variables from the target type, the aliases
- // record the alternative names used throughout the ITD expression that must map to
+ // For ITDs on generic types that use type variables from the target
+ // type, the aliases
+ // record the alternative names used throughout the ITD expression that
+ // must map to
// the same value as the type variables real name.
if (aliases != null) {
int posn = 0;
for (Iterator iter = aliases.iterator(); iter.hasNext();) {
String typeVariableAlias = (String) iter.next();
- typeMap.put(typeVariableAlias, (!typeParametersSupplied ? typeVariables[posn].getFirstBound()
- : typeParameters[posn]));
+ typeMap.put(typeVariableAlias,
+ (!typeParametersSupplied ? typeVariables[posn]
+ .getFirstBound() : typeParameters[posn]));
posn++;
}
}
- UnresolvedType parameterizedReturnType = parameterize(getGenericReturnType(), typeMap, isParameterized);
+ UnresolvedType parameterizedReturnType = parameterize(
+ getGenericReturnType(), typeMap, isParameterized);
UnresolvedType[] parameterizedParameterTypes = new UnresolvedType[getGenericParameterTypes().length];
UnresolvedType[] genericParameterTypes = getGenericParameterTypes();
for (int i = 0; i < parameterizedParameterTypes.length; i++) {
- parameterizedParameterTypes[i] = parameterize(genericParameterTypes[i], typeMap, isParameterized);
+ parameterizedParameterTypes[i] = parameterize(
+ genericParameterTypes[i], typeMap, isParameterized);
}
- ResolvedMemberImpl ret = new ResolvedMemberImpl(getKind(), newDeclaringType, getModifiers(), parameterizedReturnType,
+ ResolvedMemberImpl ret = new ResolvedMemberImpl(getKind(),
+ newDeclaringType, getModifiers(), parameterizedReturnType,
getName(), parameterizedParameterTypes, getExceptions(), this);
ret.setTypeVariables(getTypeVariables());
ret.setSourceContext(getSourceContext());
}
/**
- * Replace occurrences of type variables in the signature with values contained in the map. The map is of the form
- * A=String,B=Integer and so a signature List<A> Foo.m(B i) {} would become List<String> Foo.m(Integer i) {}
+ * Replace occurrences of type variables in the signature with values
+ * contained in the map. The map is of the form A=String,B=Integer and so a
+ * signature List<A> Foo.m(B i) {} would become List<String> Foo.m(Integer
+ * i) {}
*/
public ResolvedMember parameterizedWith(Map m, World w) {
// if (//isParameterized && <-- might need this bit...
// !getDeclaringType().isGenericType()) {
- // throw new IllegalStateException("Can't ask to parameterize a member of non-generic type: "+getDeclaringType()+" kind("+
+ // throw new IllegalStateException(
+ // "Can't ask to parameterize a member of non-generic type: "
+ // +getDeclaringType()+" kind("+
// getDeclaringType().typeKind+")");
// }
declaringType = declaringType.resolve(w);
if (declaringType.isRawType())
declaringType = ((ResolvedType) declaringType).getGenericType();
// TypeVariable[] typeVariables = getDeclaringType().getTypeVariables();
- // if (isParameterized && (typeVariables.length != typeParameters.length)) {
- // throw new IllegalStateException("Wrong number of type parameters supplied");
+ // if (isParameterized && (typeVariables.length !=
+ // typeParameters.length)) {
+ // throw new
+ // IllegalStateException("Wrong number of type parameters supplied");
// }
// Map typeMap = new HashMap();
- // boolean typeParametersSupplied = typeParameters!=null && typeParameters.length>0;
+ // boolean typeParametersSupplied = typeParameters!=null &&
+ // typeParameters.length>0;
// if (typeVariables!=null) {
- // // If no 'replacements' were supplied in the typeParameters array then collapse
+ // // If no 'replacements' were supplied in the typeParameters array
+ // then collapse
// // type variables to their first bound.
// for (int i = 0; i < typeVariables.length; i++) {
- // UnresolvedType ut = (!typeParametersSupplied?typeVariables[i].getFirstBound():typeParameters[i]);
+ // UnresolvedType ut =
+ // (!typeParametersSupplied?typeVariables[i].getFirstBound
+ // ():typeParameters[i]);
// typeMap.put(typeVariables[i].getName(),ut);
// }
// }
- // // For ITDs on generic types that use type variables from the target type, the aliases
- // // record the alternative names used throughout the ITD expression that must map to
+ // // For ITDs on generic types that use type variables from the target
+ // type, the aliases
+ // // record the alternative names used throughout the ITD expression
+ // that must map to
// // the same value as the type variables real name.
// if (aliases!=null) {
// int posn = 0;
// for (Iterator iter = aliases.iterator(); iter.hasNext();) {
// String typeVariableAlias = (String) iter.next();
- // typeMap.put(typeVariableAlias,(!typeParametersSupplied?typeVariables[posn].getFirstBound():typeParameters[posn]));
+ // typeMap.put(typeVariableAlias,(!typeParametersSupplied?typeVariables[
+ // posn].getFirstBound():typeParameters[posn]));
// posn++;
// }
// }
- UnresolvedType parameterizedReturnType = parameterize(getGenericReturnType(), m, true, w);
+ UnresolvedType parameterizedReturnType = parameterize(
+ getGenericReturnType(), m, true, w);
UnresolvedType[] parameterizedParameterTypes = new UnresolvedType[getGenericParameterTypes().length];
UnresolvedType[] genericParameterTypes = getGenericParameterTypes();
for (int i = 0; i < parameterizedParameterTypes.length; i++) {
- parameterizedParameterTypes[i] = parameterize(genericParameterTypes[i], m, true, w);
+ parameterizedParameterTypes[i] = parameterize(
+ genericParameterTypes[i], m, true, w);
}
- ResolvedMemberImpl ret = new ResolvedMemberImpl(getKind(), declaringType, getModifiers(), parameterizedReturnType,
+ ResolvedMemberImpl ret = new ResolvedMemberImpl(getKind(),
+ declaringType, getModifiers(), parameterizedReturnType,
getName(), parameterizedParameterTypes, getExceptions(), this);
ret.setTypeVariables(getTypeVariables());
ret.setSourceContext(getSourceContext());
return typeVariables;
}
- protected UnresolvedType parameterize(UnresolvedType aType, Map typeVariableMap, boolean inParameterizedType) {
+ protected UnresolvedType parameterize(UnresolvedType aType,
+ Map typeVariableMap, boolean inParameterizedType) {
return parameterize(aType, typeVariableMap, inParameterizedType, null);
}
- protected UnresolvedType parameterize(UnresolvedType aType, Map typeVariableMap, boolean inParameterizedType, World w) {
+ protected UnresolvedType parameterize(UnresolvedType aType,
+ Map typeVariableMap, boolean inParameterizedType, World w) {
if (aType instanceof TypeVariableReference) {
- String variableName = ((TypeVariableReference) aType).getTypeVariable().getName();
+ String variableName = ((TypeVariableReference) aType)
+ .getTypeVariable().getName();
if (!typeVariableMap.containsKey(variableName)) {
- return aType; // if the type variable comes from the method (and not the type) thats OK
+ return aType; // if the type variable comes from the method (and
+ // not the type) thats OK
}
return (UnresolvedType) typeVariableMap.get(variableName);
} else if (aType.isParameterizedType()) {
if (w != null)
aType = aType.resolve(w);
else {
- aType = aType.resolve(((ResolvedType) getDeclaringType()).getWorld());
+ aType = aType.resolve(((ResolvedType) getDeclaringType())
+ .getWorld());
}
// }
return aType.parameterize(typeVariableMap);
String sig = aType.getSignature();
while (sig.charAt(dims) == '[')
dims++;
- UnresolvedType componentSig = UnresolvedType.forSignature(sig.substring(dims));
- UnresolvedType arrayType = ResolvedType.makeArray(parameterize(componentSig, typeVariableMap, inParameterizedType),
- dims);
+ UnresolvedType componentSig = UnresolvedType.forSignature(sig
+ .substring(dims));
+ UnresolvedType arrayType = ResolvedType.makeArray(parameterize(
+ componentSig, typeVariableMap, inParameterizedType), dims);
return arrayType;
}
return aType;
}
/**
- * If this member is defined by a parameterized super-type, return the erasure of that member. For example: interface I<T> { T
- * foo(T aTea); } class C implements I<String> { String foo(String aString) { return "something"; } } The resolved member for
- * C.foo has signature String foo(String). The erasure of that member is Object foo(Object) -- use upper bound of type variable.
- * A type is a supertype of itself.
+ * If this member is defined by a parameterized super-type, return the
+ * erasure of that member. For example: interface I<T> { T foo(T aTea); }
+ * class C implements I<String> { String foo(String aString) { return
+ * "something"; } } The resolved member for C.foo has signature String
+ * foo(String). The erasure of that member is Object foo(Object) -- use
+ * upper bound of type variable. A type is a supertype of itself.
*/
// public ResolvedMember getErasure() {
// if (calculatedMyErasure) return myErasure;
// } else {
// // we have one or more parameterized super types.
// // this member may be defined by one of them... we need to find out.
- // Collection declaringTypes = this.getDeclaringTypes(resolvedDeclaringType.getWorld());
+ // Collection declaringTypes =
+ // this.getDeclaringTypes(resolvedDeclaringType.getWorld());
// for (Iterator iter = declaringTypes.iterator(); iter.hasNext();) {
// ResolvedType aDeclaringType = (ResolvedType) iter.next();
// if (aDeclaringType.isParameterizedType()) {
// // we've found the (a?) parameterized type that defines this member.
// // now get the erasure of it
- // ResolvedMemberImpl matchingMember = (ResolvedMemberImpl) aDeclaringType.lookupMemberNoSupers(this);
- // if (matchingMember != null && matchingMember.backingGenericMember != null) {
+ // ResolvedMemberImpl matchingMember = (ResolvedMemberImpl)
+ // aDeclaringType.lookupMemberNoSupers(this);
+ // if (matchingMember != null && matchingMember.backingGenericMember !=
+ // null) {
// myErasure = matchingMember.backingGenericMember;
// return myErasure;
// }
}
/**
- * For ITDs, we use the default factory methods to build a resolved member, then alter a couple of characteristics using this
- * method - this is safe.
+ * For ITDs, we use the default factory methods to build a resolved member,
+ * then alter a couple of characteristics using this method - this is safe.
*/
public void resetName(String newName) {
this.name = newName;
}
/**
- * Returns a copy of this member but with the declaring type swapped. Copy only needs to be shallow.
+ * Returns a copy of this member but with the declaring type swapped. Copy
+ * only needs to be shallow.
*
* @param newDeclaringType
*/
- public JoinPointSignature withSubstituteDeclaringType(ResolvedType newDeclaringType) {
+ public JoinPointSignature withSubstituteDeclaringType(
+ ResolvedType newDeclaringType) {
JoinPointSignature ret = new JoinPointSignature(this, newDeclaringType);
return ret;
}
/**
- * Returns true if this member matches the other. The matching takes into account name and parameter types only. When comparing
- * parameter types, we allow any type variable to match any other type variable regardless of bounds.
+ * Returns true if this member matches the other. The matching takes into
+ * account name and parameter types only. When comparing parameter types, we
+ * allow any type variable to match any other type variable regardless of
+ * bounds.
*/
public boolean matches(ResolvedMember aCandidateMatch) {
ResolvedMemberImpl candidateMatchImpl = (ResolvedMemberImpl) aCandidateMatch;
if (!getName().equals(aCandidateMatch.getName()))
return false;
UnresolvedType[] myParameterTypes = getGenericParameterTypes();
- UnresolvedType[] candidateParameterTypes = aCandidateMatch.getGenericParameterTypes();
+ UnresolvedType[] candidateParameterTypes = aCandidateMatch
+ .getGenericParameterTypes();
if (myParameterTypes.length != candidateParameterTypes.length)
return false;
String myParameterSignature = getParameterSigWithBoundsRemoved();
- String candidateParameterSignature = candidateMatchImpl.getParameterSigWithBoundsRemoved();
+ String candidateParameterSignature = candidateMatchImpl
+ .getParameterSigWithBoundsRemoved();
if (myParameterSignature.equals(candidateParameterSignature)) {
return true;
} else {
// try erasure
myParameterSignature = getParameterSignatureErased();
- candidateParameterSignature = candidateMatchImpl.getParameterSignatureErased();
+ candidateParameterSignature = candidateMatchImpl
+ .getParameterSignatureErased();
return myParameterSignature.equals(candidateParameterSignature);
}
}
/**
- * converts e.g. <T extends Number>.... List<T> to just Ljava/util/List<T;>; whereas the full signature would be
+ * converts e.g. <T extends Number>.... List<T> to just Ljava/util/List<T;>;
+ * whereas the full signature would be
* Ljava/util/List<T:Ljava/lang/Number;>;
*/
private String myParameterSignatureWithBoundsRemoved = null;
*/
private String myParameterSignatureErasure = null;
- // does NOT produce a meaningful java signature, but does give a unique string suitable for
+ // does NOT produce a meaningful java signature, but does give a unique
+ // string suitable for
// comparison.
private String getParameterSigWithBoundsRemoved() {
if (myParameterSignatureWithBoundsRemoved != null)
StringBuffer sig = new StringBuffer();
UnresolvedType[] myParameterTypes = getGenericParameterTypes();
for (int i = 0; i < myParameterTypes.length; i++) {
- appendSigWithTypeVarBoundsRemoved(myParameterTypes[i], sig, new HashSet());
+ appendSigWithTypeVarBoundsRemoved(myParameterTypes[i], sig,
+ new HashSet());
}
myParameterSignatureWithBoundsRemoved = sig.toString();
return myParameterSignatureWithBoundsRemoved;
}
/**
- * Return the erased form of the signature with bounds collapsed for type variables, etc. Does not include the return type, @see
- * getParam
+ * Return the erased form of the signature with bounds collapsed for type
+ * variables, etc. Does not include the return type, @see getParam
*/
public String getParameterSignatureErased() {
if (myParameterSignatureErasure != null)
return sb.toString();
}
- // does NOT produce a meaningful java signature, but does give a unique string suitable for
+ // does NOT produce a meaningful java signature, but does give a unique
+ // string suitable for
// comparison.
- public static void appendSigWithTypeVarBoundsRemoved(UnresolvedType aType, StringBuffer toBuffer, Set alreadyUsedTypeVars) {
+ public static void appendSigWithTypeVarBoundsRemoved(UnresolvedType aType,
+ StringBuffer toBuffer, Set alreadyUsedTypeVars) {
if (aType.isTypeVariableReference()) {
TypeVariableReferenceType typeVariableRT = (TypeVariableReferenceType) aType;
// pr204505
toBuffer.append("...");
} else {
alreadyUsedTypeVars.add(aType);
- appendSigWithTypeVarBoundsRemoved(typeVariableRT.getUpperBound(), toBuffer, alreadyUsedTypeVars);
+ appendSigWithTypeVarBoundsRemoved(typeVariableRT
+ .getUpperBound(), toBuffer, alreadyUsedTypeVars);
}
// toBuffer.append("T;");
} else if (aType.isParameterizedType()) {
toBuffer.append(aType.getRawType().getSignature());
toBuffer.append("<");
for (int i = 0; i < aType.getTypeParameters().length; i++) {
- appendSigWithTypeVarBoundsRemoved(aType.getTypeParameters()[i], toBuffer, alreadyUsedTypeVars);
+ appendSigWithTypeVarBoundsRemoved(aType.getTypeParameters()[i],
+ toBuffer, alreadyUsedTypeVars);
}
toBuffer.append(">;");
} else {
// modifiers
int mods = modifiers;
if ((mods & 4096) > 0)
- mods = mods - 4096; // remove synthetic (added in the ASM case but not in the BCEL case...)
+ mods = mods - 4096; // remove synthetic (added in the ASM case but
+ // not in the BCEL case...)
if ((mods & 512) > 0)
- mods = mods - 512; // remove interface (added in the BCEL case but not in the ASM case...)
+ mods = mods - 512; // remove interface (added in the BCEL case but
+ // not in the ASM case...)
if ((mods & 131072) > 0)
- mods = mods - 131072; // remove deprecated (added in the ASM case but not in the BCEL case...)
+ mods = mods - 131072; // remove deprecated (added in the ASM case
+ // but not in the BCEL case...)
String modsStr = Modifier.toString(mods);
if (modsStr.length() != 0)
r.append(modsStr).append("(" + mods + ")").append(" ");
if (kind != FIELD) {
r.append("(");
UnresolvedType[] params = getGenericParameterTypes();
- boolean parameterNamesExist = showParameterNames && parameterNames != null && parameterNames.length == params.length;
+ boolean parameterNamesExist = showParameterNames
+ && parameterNames != null
+ && parameterNames.length == params.length;
if (params.length != 0) {
for (int i = 0, len = params.length; i < len; i++) {
if (i > 0)
return r.toString();
}
- // SECRETAPI - controlling whether parameter names come out in the debug string (for testing purposes)
+ // SECRETAPI - controlling whether parameter names come out in the debug
+ // string (for testing purposes)
public static boolean showParameterNames = true;
public String toGenericString() {
// check the declaring type!
return declaringType.getTypeVariableNamed(name);
- // Do generic aspects with ITDs that share type variables with the aspect and the target type and have their own tvars cause
+ // Do generic aspects with ITDs that share type variables with the
+ // aspect and the target type and have their own tvars cause
// this to be messier?
}
public void evictWeavingState() {
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
- throw new UnsupportedOperationException("You should resolve this member and call getAnnotationOfType() on the result...");
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
+ throw new UnsupportedOperationException(
+ "You should resolve this member and call getAnnotationOfType() on the result...");
}
}
import org.aspectj.weaver.patterns.Declare;
import org.aspectj.weaver.patterns.PerClause;
-public abstract class ResolvedType extends UnresolvedType implements AnnotatedElement {
+public abstract class ResolvedType extends UnresolvedType implements
+ AnnotatedElement {
public static final ResolvedType[] EMPTY_RESOLVED_TYPE_ARRAY = new ResolvedType[0];
public static final String PARAMETERIZED_TYPE_IDENTIFIER = "P";
- // Set during a type pattern match call - this currently used to hold the annotations
+ // Set during a type pattern match call - this currently used to hold the
+ // annotations
// that may be attached to a type when it used as a parameter
public ResolvedType[] temporaryAnnotationTypes;
private ResolvedType[] resolvedTypeParams;
this.world = world;
}
- protected ResolvedType(String signature, String signatureErasure, World world) {
+ protected ResolvedType(String signature, String signatureErasure,
+ World world) {
super(signature, signatureErasure);
this.world = world;
}
// ---- things that don't require a world
/**
- * Returns an iterator through ResolvedType objects representing all the direct supertypes of this type. That is, through the
- * superclass, if any, and all declared interfaces.
+ * Returns an iterator through ResolvedType objects representing all the
+ * direct supertypes of this type. That is, through the superclass, if any,
+ * and all declared interfaces.
*/
public final Iterator getDirectSupertypes() {
Iterator ifacesIterator = Iterators.array(getDeclaredInterfaces());
public abstract ResolvedMember[] getDeclaredPointcuts();
/**
- * Returns a ResolvedType object representing the superclass of this type, or null. If this represents a java.lang.Object, a
- * primitive type, or void, this method returns null.
+ * Returns a ResolvedType object representing the superclass of this type,
+ * or null. If this represents a java.lang.Object, a primitive type, or
+ * void, this method returns null.
*/
public abstract ResolvedType getSuperclass();
/**
- * Returns the modifiers for this type. <p/> See {@link Class#getModifiers()} for a description of the weirdness of this methods
- * on primitives and arrays.
+ * Returns the modifiers for this type. <p/> See
+ * {@link Class#getModifiers()} for a description of the weirdness of this
+ * methods on primitives and arrays.
*
- * @param world the {@link World} in which the lookup is made.
+ * @param world
+ * the {@link World} in which the lookup is made.
* @return an int representing the modifiers for this type
* @see java.lang.reflect.Modifier
*/
public abstract int getModifiers();
- // return true if this resolved type couldn't be found (but we know it's name maybe)
+ // return true if this resolved type couldn't be found (but we know it's
+ // name maybe)
public boolean isMissing() {
return false;
}
- // FIXME asc I wonder if in some circumstances MissingWithKnownSignature should not be considered
+ // FIXME asc I wonder if in some circumstances MissingWithKnownSignature
+ // should not be considered
// 'really' missing as some code can continue based solely on the signature
public static boolean isMissing(UnresolvedType unresolved) {
if (unresolved instanceof ResolvedType) {
return EMPTY_RESOLVED_TYPE_ARRAY;
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
return null;
}
// ---- difficult things
/**
- * returns an iterator through all of the fields of this type, in order for checking from JVM spec 2ed 5.4.3.2. This means that
- * the order is <p/>
+ * returns an iterator through all of the fields of this type, in order for
+ *
checking from JVM spec 2ed 5.4.3.2. This means that the order is <p/>
* <ul>
* <li>fields from current class</li>
* <li>recur into direct superinterfaces</li>
* <li>recur into superclass</li>
* </ul>
- * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't
+ * spiral out into 2^n land.
*/
public Iterator getFields() {
final Iterators.Filter dupFilter = Iterators.dupFilter();
Iterators.Getter typeGetter = new Iterators.Getter() {
public Iterator get(Object o) {
- return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ return dupFilter.filter(((ResolvedType) o)
+ .getDirectSupertypes());
}
};
Iterators.Getter fieldGetter = new Iterators.Getter() {
return Iterators.array(((ResolvedType) o).getDeclaredFields());
}
};
- return Iterators.mapOver(Iterators.recur(this, typeGetter), fieldGetter);
+ return Iterators
+ .mapOver(Iterators.recur(this, typeGetter), fieldGetter);
}
/**
- * returns an iterator through all of the methods of this type, in order for checking from JVM spec 2ed 5.4.3.3. This means that
- * the order is <p/>
+ * returns an iterator through all of the methods of this type, in order for
+ *
checking from JVM spec 2ed 5.4.3.3. This means that the order is <p/>
* <ul>
* <li>methods from current class</li>
* <li>recur into superclass, all the way up, not touching interfaces</li>
* <li>recur into all superinterfaces, in some unspecified order</li>
* </ul>
- * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land. NOTE: Take a look at the
- * javadoc on getMethodsWithoutIterator() to see if you are sensitive to a quirk in getMethods()
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't
+ * spiral out into 2^n land. NOTE: Take a look at the javadoc on
+ * getMethodsWithoutIterator() to see if you are sensitive to a quirk in
+ * getMethods()
*/
public Iterator getMethods() {
final Iterators.Filter dupFilter = Iterators.dupFilter();
Iterators.Getter ifaceGetter = new Iterators.Getter() {
public Iterator get(Object o) {
- return dupFilter.filter(Iterators.array(((ResolvedType) o).getDeclaredInterfaces()));
+ return dupFilter.filter(Iterators.array(((ResolvedType) o)
+ .getDeclaredInterfaces()));
}
};
Iterators.Getter methodGetter = new Iterators.Getter() {
}
/**
- * Return a list of methods, first those declared on this class, then those declared on the superclass (recurse) and then those
- * declared on the superinterfaces. The getMethods() call above doesn't quite work the same as it will (through the iterator)
- * return methods declared on *this* class twice, once at the start and once at the end - I couldn't debug that problem, so
- * created this alternative.
+ * Return a list of methods, first those declared on this class, then those
+ * declared on the superclass (recurse) and then those declared on the
+ * superinterfaces. The getMethods() call above doesn't quite work the same
+ * as it will (through the iterator) return methods declared on *this* class
+ * twice, once at the start and once at the end - I couldn't debug that
+ * problem, so created this alternative.
*/
- public List getMethodsWithoutIterator(boolean includeITDs, boolean allowMissing) {
+ public List getMethodsWithoutIterator(boolean includeITDs,
+ boolean allowMissing) {
List methods = new ArrayList();
Set knowninterfaces = new HashSet();
addAndRecurse(knowninterfaces, methods, this, includeITDs, allowMissing);
return methods;
}
- private void addAndRecurse(Set knowninterfaces, List collector, ResolvedType rtx, boolean includeITDs, boolean allowMissing) {
- collector.addAll(Arrays.asList(rtx.getDeclaredMethods())); // Add the methods declared on this type
+ private void addAndRecurse(Set knowninterfaces, List collector,
+ ResolvedType rtx, boolean includeITDs, boolean allowMissing) {
+ collector.addAll(Arrays.asList(rtx.getDeclaredMethods())); // Add the
+ // methods
+ // declared
+ // on this
+ // type
// now add all the inter-typed members too
if (includeITDs && rtx.interTypeMungers != null) {
for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
ConcreteTypeMunger tm = (ConcreteTypeMunger) i.next();
ResolvedMember rm = tm.getSignature();
- if (rm != null) { // new parent type munger can have null signature...
+ if (rm != null) { // new parent type munger can have null
+ // signature...
collector.add(tm.getSignature());
}
}
if (!rtx.equals(ResolvedType.OBJECT)) {
ResolvedType superType = rtx.getSuperclass();
if (superType != null && !superType.isMissing()) {
- addAndRecurse(knowninterfaces, collector, superType, includeITDs, allowMissing); // Recurse if we aren't at the top
+ addAndRecurse(knowninterfaces, collector, superType,
+ includeITDs, allowMissing); // Recurse if we aren't at
+ // the top
}
}
- ResolvedType[] interfaces = rtx.getDeclaredInterfaces(); // Go through the interfaces on the way back down
+ ResolvedType[] interfaces = rtx.getDeclaredInterfaces(); // Go through
+ // the
+ // interfaces
+ // on the
+ // way back
+ // down
for (int i = 0; i < interfaces.length; i++) {
ResolvedType iface = interfaces[i];
// as those are used for @AJ ITD and we precisely want to skip those
boolean shouldSkip = false;
for (int j = 0; j < rtx.interTypeMungers.size(); j++) {
- ConcreteTypeMunger munger = (ConcreteTypeMunger) rtx.interTypeMungers.get(j);
- if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
- && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953
+ ConcreteTypeMunger munger = (ConcreteTypeMunger) rtx.interTypeMungers
+ .get(j);
+ if (munger.getMunger() != null
+ && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
+ && ((NewParentTypeMunger) munger.getMunger())
+ .getNewParent().equals(iface) // pr171953
) {
shouldSkip = true;
break;
}
}
- if (!shouldSkip && !knowninterfaces.contains(iface)) { // Dont do interfaces more than once
+ if (!shouldSkip && !knowninterfaces.contains(iface)) { // Dont do
+ // interfaces
+ // more than
+ // once
knowninterfaces.add(iface);
if (allowMissing && iface.isMissing()) {
if (iface instanceof MissingResolvedTypeWithKnownSignature) {
- ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods();
+ ((MissingResolvedTypeWithKnownSignature) iface)
+ .raiseWarningOnMissingInterfaceWhilstFindingMethods();
}
} else {
- addAndRecurse(knowninterfaces, collector, iface, includeITDs, allowMissing);
+ addAndRecurse(knowninterfaces, collector, iface,
+ includeITDs, allowMissing);
}
}
}
ResolvedMember f = (ResolvedMember) i.next();
if (matches(f, m))
return f;
- if (f.hasBackingGenericMember() && m.getName().equals(f.getName())) { // might be worth checking the method behind the
+ if (f.hasBackingGenericMember() && m.getName().equals(f.getName())) { // might
+ // be
+ // worth
+ // checking
+ // the
+ // method
+ // behind
+ // the
// parameterized method (see pr137496)
if (matches(f.getBackingGenericMember(), m))
return f;
}
/**
- * Looks for the first member in the hierarchy matching aMember. This method differs from lookupMember(Member) in that it takes
- * into account parameters which are type variables - which clearly an unresolved Member cannot do since it does not know
- * anything about type variables.
+ * Looks for the first member in the hierarchy matching aMember. This method
+ * differs from lookupMember(Member) in that it takes into account
+ * parameters which are type variables - which clearly an unresolved Member
+ * cannot do since it does not know anything about type variables.
*/
- public ResolvedMember lookupResolvedMember(ResolvedMember aMember, boolean allowMissing) {
+ public ResolvedMember lookupResolvedMember(ResolvedMember aMember,
+ boolean allowMissing) {
Iterator toSearch = null;
ResolvedMember found = null;
- if ((aMember.getKind() == Member.METHOD) || (aMember.getKind() == Member.CONSTRUCTOR)) {
+ if ((aMember.getKind() == Member.METHOD)
+ || (aMember.getKind() == Member.CONSTRUCTOR)) {
toSearch = getMethodsWithoutIterator(true, allowMissing).iterator();
} else {
if (aMember.getKind() != Member.FIELD)
- throw new IllegalStateException("I didn't know you would look for members of kind " + aMember.getKind());
+ throw new IllegalStateException(
+ "I didn't know you would look for members of kind "
+ + aMember.getKind());
toSearch = getFields();
}
while (toSearch.hasNext()) {
if (equalSignatures)
return true;
- // If they aren't the same, we need to allow for covariance ... where one sig might be ()LCar; and
+ // If they aren't the same, we need to allow for covariance ... where
+ // one sig might be ()LCar; and
// the subsig might be ()LFastCar; - where FastCar is a subclass of Car
- boolean equalCovariantSignatures = m1.getParameterSignature().equals(m2.getParameterSignature());
+ boolean equalCovariantSignatures = m1.getParameterSignature().equals(
+ m2.getParameterSignature());
if (equalCovariantSignatures)
return true;
}
/**
- * returns an iterator through all of the pointcuts of this type, in order for checking from JVM spec 2ed 5.4.3.2 (as for
- * fields). This means that the order is <p/>
+ * returns an iterator through all of the pointcuts of this type, in order
+ * for checking from JVM spec 2ed 5.4.3.2 (as for fields). This means that
+ * the order is <p/>
* <ul>
* <li>pointcuts from current class</li>
* <li>recur into direct superinterfaces</li>
* <li>recur into superclass</li>
* </ul>
- * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't
+ * spiral out into 2^n land.
*/
public Iterator getPointcuts() {
final Iterators.Filter dupFilter = Iterators.dupFilter();
// same order as fields
Iterators.Getter typeGetter = new Iterators.Getter() {
public Iterator get(Object o) {
- return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ return dupFilter.filter(((ResolvedType) o)
+ .getDirectSupertypes());
}
};
Iterators.Getter pointcutGetter = new Iterators.Getter() {
public Iterator get(Object o) {
// System.err.println("getting for " + o);
- return Iterators.array(((ResolvedType) o).getDeclaredPointcuts());
+ return Iterators.array(((ResolvedType) o)
+ .getDeclaredPointcuts());
}
};
- return Iterators.mapOver(Iterators.recur(this, typeGetter), pointcutGetter);
+ return Iterators.mapOver(Iterators.recur(this, typeGetter),
+ pointcutGetter);
}
public ResolvedPointcutDefinition findPointcut(String name) {
// System.err.println("looking for pointcuts " + this);
for (Iterator i = getPointcuts(); i.hasNext();) {
- ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next();
+ ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i
+ .next();
// System.err.println(f);
if (name.equals(f.getName())) {
return f;
// ??? collecting data-structure, shouldn't really be a field
public CrosscuttingMembers crosscuttingMembers;
- public CrosscuttingMembers collectCrosscuttingMembers(boolean shouldConcretizeIfNeeded) {
- crosscuttingMembers = new CrosscuttingMembers(this, shouldConcretizeIfNeeded);
+ public CrosscuttingMembers collectCrosscuttingMembers(
+ boolean shouldConcretizeIfNeeded) {
+ crosscuttingMembers = new CrosscuttingMembers(this,
+ shouldConcretizeIfNeeded);
crosscuttingMembers.setPerClause(getPerClause());
crosscuttingMembers.addShadowMungers(collectShadowMungers());
// GENERICITDFIX
// crosscuttingMembers.addTypeMungers(collectTypeMungers());
crosscuttingMembers.addTypeMungers(getTypeMungers());
- // FIXME AV - skip but needed ?? or ?? crosscuttingMembers.addLateTypeMungers(getLateTypeMungers());
- crosscuttingMembers.addDeclares(collectDeclares(!this.doesNotExposeShadowMungers()));
+ // FIXME AV - skip but needed ?? or ??
+ // crosscuttingMembers.addLateTypeMungers(getLateTypeMungers());
+ crosscuttingMembers.addDeclares(collectDeclares(!this
+ .doesNotExposeShadowMungers()));
crosscuttingMembers.addPrivilegedAccesses(getPrivilegedAccesses());
- // System.err.println("collected cc members: " + this + ", " + collectDeclares());
+ // System.err.println("collected cc members: " + this + ", " +
+ // collectDeclares());
return crosscuttingMembers;
}
final Iterators.Filter dupFilter = Iterators.dupFilter();
Iterators.Getter typeGetter = new Iterators.Getter() {
public Iterator get(Object o) {
- return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ return dupFilter.filter(((ResolvedType) o)
+ .getDirectSupertypes());
}
};
Iterator typeIterator = Iterators.recur(this, typeGetter);
}
private final Collection collectShadowMungers() {
- if (!this.isAspect() || this.isAbstract() || this.doesNotExposeShadowMungers())
+ if (!this.isAspect() || this.isAbstract()
+ || this.doesNotExposeShadowMungers())
return Collections.EMPTY_LIST;
ArrayList acc = new ArrayList();
final Iterators.Filter dupFilter = Iterators.dupFilter();
Iterators.Getter typeGetter = new Iterators.Getter() {
public Iterator get(Object o) {
- return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ return dupFilter.filter(((ResolvedType) o)
+ .getDirectSupertypes());
}
};
Iterator typeIterator = Iterators.recur(this, typeGetter);
return false;
}
- public void addAnnotation(AnnotationX annotationX) {
- throw new RuntimeException("ResolvedType.addAnnotation() should never be called");
+ public void addAnnotation(AnnotationAJ annotationX) {
+ throw new RuntimeException(
+ "ResolvedType.addAnnotation() should never be called");
}
- public AnnotationX[] getAnnotations() {
- throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
+ public AnnotationAJ[] getAnnotations() {
+ throw new RuntimeException(
+ "ResolvedType.getAnnotations() should never be called");
}
/**
ShadowMunger munger = methods[i].getAssociatedShadowMunger();
if (munger != null) {
if (ajMembersNeedParameterization()) {
- // munger.setPointcut(munger.getPointcut().parameterizeWith(typeVariableMap));
+ // munger.setPointcut(munger.getPointcut().parameterizeWith(
+ // typeVariableMap));
munger = munger.parameterizeWith(this, typeVariableMap);
if (munger instanceof Advice) {
Advice advice = (Advice) munger;
// update to use the parameterized signature...
- UnresolvedType[] ptypes = methods[i].getGenericParameterTypes();
+ UnresolvedType[] ptypes = methods[i]
+ .getGenericParameterTypes();
UnresolvedType[] newPTypes = new UnresolvedType[ptypes.length];
for (int j = 0; j < ptypes.length; j++) {
if (ptypes[j] instanceof TypeVariableReferenceType) {
TypeVariableReferenceType tvrt = (TypeVariableReferenceType) ptypes[j];
- if (typeVariableMap.containsKey(tvrt.getTypeVariable().getName())) {
- newPTypes[j] = (UnresolvedType) typeVariableMap.get(tvrt.getTypeVariable().getName());
+ if (typeVariableMap.containsKey(tvrt
+ .getTypeVariable().getName())) {
+ newPTypes[j] = (UnresolvedType) typeVariableMap
+ .get(tvrt.getTypeVariable()
+ .getName());
} else {
newPTypes[j] = ptypes[j];
}
private ResolvedMember[] filterInJavaVisible(ResolvedMember[] ms) {
List l = new ArrayList();
for (int i = 0, len = ms.length; i < len; i++) {
- if (!ms[i].isAjSynthetic() && ms[i].getAssociatedShadowMunger() == null) {
+ if (!ms[i].isAjSynthetic()
+ && ms[i].getAssociatedShadowMunger() == null) {
l.add(ms[i]);
}
}
public static final Missing MISSING = new Missing();
/** Reset the static state in the primitive types */
- // OPTIMIZE I think we have a bug here because primitives are static and the world they use may vary (or may even be
+ // OPTIMIZE I think we have a bug here because primitives are static and the
+ // world they use may vary (or may even be
// null)
public static void resetPrimitives() {
BYTE.world = null;
public static ResolvedType makeArray(ResolvedType type, int dim) {
if (dim == 0)
return type;
- ResolvedType array = new ArrayReferenceType("[" + type.getSignature(), "[" + type.getErasureSignature(), type.getWorld(),
- type);
+ ResolvedType array = new ArrayReferenceType("[" + type.getSignature(),
+ "[" + type.getErasureSignature(), type.getWorld(), type);
return makeArray(array, dim - 1);
}
if (!other.isPrimitiveType()) {
if (!world.isInJava5Mode())
return false;
- return validBoxing.contains(this.getSignature() + other.getSignature());
+ return validBoxing.contains(this.getSignature()
+ + other.getSignature());
}
return assignTable[((Primitive) other).index][index];
}
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
+ public final boolean isAssignableFrom(ResolvedType other,
+ boolean allowMissing) {
return isAssignableFrom(other);
}
return noConvertTable[((Primitive) other).index][index];
}
- private static final boolean[][] assignTable = {// to: B C D F I J S V Z from
- { true, true, true, true, true, true, true, false, false }, // B
+ private static final boolean[][] assignTable = {// to: B C D F I J S V Z
+ // from
+ { true, true, true, true, true, true, true, false, false }, // B
{ false, true, true, true, true, true, false, false, false }, // C
{ false, false, true, false, false, false, false, false, false }, // D
{ false, false, true, true, false, false, false, false, false }, // F
{ false, false, false, false, false, false, false, true, false }, // V
{ false, false, false, false, false, false, false, false, true }, // Z
};
- private static final boolean[][] noConvertTable = {// to: B C D F I J S V Z from
- { true, true, false, false, true, false, true, false, false }, // B
+ private static final boolean[][] noConvertTable = {// to: B C D F I J S
+ // V Z from
+ { true, true, false, false, true, false, true, false, false }, // B
{ false, true, false, false, true, false, false, false, false }, // C
{ false, false, true, false, false, false, false, false, false }, // D
{ false, false, false, true, false, false, false, false, false }, // F
return false;
}
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
+ public final boolean isAssignableFrom(ResolvedType other,
+ boolean allowMissing) {
return false;
}
}
/**
- * Look up a member, takes into account any ITDs on this type. return null if not found
+ * Look up a member, takes into account any ITDs on this type. return null
+ * if not found
*/
public ResolvedMember lookupMemberNoSupers(Member member) {
ResolvedMember ret = lookupDirectlyDeclaredMemberNoSupers(member);
if (member.getKind() == Member.FIELD) {
ret = lookupMember(member, getDeclaredFields());
} else {
- // assert member.getKind() == Member.METHOD || member.getKind() == Member.CONSTRUCTOR
+ // assert member.getKind() == Member.METHOD || member.getKind() ==
+ // Member.CONSTRUCTOR
ret = lookupMember(member, getDeclaredMethods());
}
return ret;
}
/**
- * This lookup has specialized behaviour - a null result tells the EclipseTypeMunger that it should make a default
- * implementation of a method on this type.
+ * This lookup has specialized behaviour - a null result tells the
+ * EclipseTypeMunger that it should make a default implementation of a
+ * method on this type.
*
* @param member
* @return
return lookupMemberIncludingITDsOnInterfaces(member, this);
}
- private ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member, ResolvedType onType) {
+ private ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member,
+ ResolvedType onType) {
ResolvedMember ret = onType.lookupMemberNoSupers(member);
if (ret != null) {
return ret;
}
/**
- * ??? This method is O(N*M) where N = number of methods and M is number of inter-type declarations in my super
+ * ??? This method is O(N*M) where N = number of methods and M is number of
+ * inter-type declarations in my super
*/
public List getInterTypeMungersIncludingSupers() {
ArrayList ret = new ArrayList();
for (Iterator iter = getDirectSupertypes(); iter.hasNext();) {
ResolvedType superType = (ResolvedType) iter.next();
if (superType == null) {
- throw new BCException("UnexpectedProblem: a supertype in the hierarchy for " + this.getName() + " is null");
+ throw new BCException(
+ "UnexpectedProblem: a supertype in the hierarchy for "
+ + this.getName() + " is null");
}
superType.collectInterTypeMungers(collector);
}
if (!superMunger.getSignature().isAbstract())
continue;
- for (Iterator iter = getInterTypeMungers().iterator(); iter.hasNext();) {
+ for (Iterator iter = getInterTypeMungers().iterator(); iter
+ .hasNext();) {
ConcreteTypeMunger myMunger = (ConcreteTypeMunger) iter.next();
- if (conflictingSignature(myMunger.getSignature(), superMunger.getSignature())) {
+ if (conflictingSignature(myMunger.getSignature(), superMunger
+ .getSignature())) {
iter1.remove();
continue outer;
}
}
/**
- * Check: 1) That we don't have any abstract type mungers unless this type is abstract. 2) That an abstract ITDM on an interface
- * is declared public. (Compiler limitation) (PR70794)
+ * Check: 1) That we don't have any abstract type mungers unless this type
+ * is abstract. 2) That an abstract ITDM on an interface is declared public.
+ * (Compiler limitation) (PR70794)
*/
public void checkInterTypeMungers() {
if (isAbstract())
boolean itdProblem = false;
- for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter.hasNext();) {
+ for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter
+ .hasNext();) {
ConcreteTypeMunger munger = (ConcreteTypeMunger) iter.next();
- itdProblem = checkAbstractDeclaration(munger) || itdProblem; // Rule 2
+ itdProblem = checkAbstractDeclaration(munger) || itdProblem; // Rule
+ // 2
}
if (itdProblem)
return; // If the rules above are broken, return right now
- for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter.hasNext();) {
+ for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter
+ .hasNext();) {
ConcreteTypeMunger munger = (ConcreteTypeMunger) iter.next();
- if (munger.getSignature() != null && munger.getSignature().isAbstract()) { // Rule 1
+ if (munger.getSignature() != null
+ && munger.getSignature().isAbstract()) { // Rule 1
if (munger.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate) {
- // ignore for @AJ ITD as munger.getSignature() is the interface method hence abstract
+ // ignore for @AJ ITD as munger.getSignature() is the
+ // interface method hence abstract
} else {
- world.getMessageHandler()
+ world
+ .getMessageHandler()
.handleMessage(
- new Message("must implement abstract inter-type declaration: " + munger.getSignature(), "",
- IMessage.ERROR, getSourceLocation(), null,
+ new Message(
+ "must implement abstract inter-type declaration: "
+ + munger.getSignature(),
+ "",
+ IMessage.ERROR,
+ getSourceLocation(),
+ null,
new ISourceLocation[] { getMungerLocation(munger) }));
}
}
}
/**
- * See PR70794. This method checks that if an abstract inter-type method declaration is made on an interface then it must also
- * be public. This is a compiler limitation that could be made to work in the future (if someone provides a worthwhile usecase)
+ * See PR70794. This method checks that if an abstract inter-type method
+ * declaration is made on an interface then it must also be public. This is
+ * a compiler limitation that could be made to work in the future (if
+ * someone provides a worthwhile usecase)
*
* @return indicates if the munger failed the check
*/
private boolean checkAbstractDeclaration(ConcreteTypeMunger munger) {
- if (munger.getMunger() != null && (munger.getMunger() instanceof NewMethodTypeMunger)) {
+ if (munger.getMunger() != null
+ && (munger.getMunger() instanceof NewMethodTypeMunger)) {
ResolvedMember itdMember = munger.getSignature();
ResolvedType onType = itdMember.getDeclaringType().resolve(world);
- if (onType.isInterface() && itdMember.isAbstract() && !itdMember.isPublic()) {
- world.getMessageHandler().handleMessage(
- new Message(WeaverMessages.format(WeaverMessages.ITD_ABSTRACT_MUST_BE_PUBLIC_ON_INTERFACE, munger
- .getSignature(), onType), "", Message.ERROR, getSourceLocation(), null,
- new ISourceLocation[] { getMungerLocation(munger) }));
+ if (onType.isInterface() && itdMember.isAbstract()
+ && !itdMember.isPublic()) {
+ world
+ .getMessageHandler()
+ .handleMessage(
+ new Message(
+ WeaverMessages
+ .format(
+ WeaverMessages.ITD_ABSTRACT_MUST_BE_PUBLIC_ON_INTERFACE,
+ munger.getSignature(),
+ onType),
+ "",
+ Message.ERROR,
+ getSourceLocation(),
+ null,
+ new ISourceLocation[] { getMungerLocation(munger) }));
return true;
}
}
}
/**
- * Get a source location for the munger. Until intertype mungers remember where they came from, the source location for the
- * munger itself is null. In these cases use the source location for the aspect containing the ITD.
+ * Get a source location for the munger. Until intertype mungers remember
+ * where they came from, the source location for the munger itself is null.
+ * In these cases use the source location for the aspect containing the ITD.
*/
private ISourceLocation getMungerLocation(ConcreteTypeMunger munger) {
ISourceLocation sloc = munger.getSourceLocation();
}
/**
- * Returns a ResolvedType object representing the declaring type of this type, or null if this type does not represent a
- * non-package-level-type. <p/> <strong>Warning</strong>: This is guaranteed to work for all member types. For anonymous/local
- * types, the only guarantee is given in JLS 13.1, where it guarantees that if you call getDeclaringType() repeatedly, you will
- * eventually get the top-level class, but it does not say anything about classes in between.
+ * Returns a ResolvedType object representing the declaring type of this
+ * type, or null if this type does not represent a non-package-level-type.
+ * <p/> <strong>Warning</strong>: This is guaranteed to work for all member
+ * types. For anonymous/local types, the only guarantee is given in JLS
+ * 13.1, where it guarantees that if you call getDeclaringType() repeatedly,
+ * you will eventually get the top-level class, but it does not say anything
+ * about classes in between.
*
* @return the declaring UnresolvedType object, or null.
*/
String name = getName();
int lastDollar = name.lastIndexOf('$');
while (lastDollar > 0) { // allow for classes starting '$' (pr120474)
- ResolvedType ret = world.resolve(UnresolvedType.forName(name.substring(0, lastDollar)), true);
+ ResolvedType ret = world.resolve(UnresolvedType.forName(name
+ .substring(0, lastDollar)), true);
if (!ResolvedType.isMissing(ret))
return ret;
lastDollar = name.lastIndexOf('$', lastDollar - 1);
return null;
}
- public static boolean isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) {
- // System.err.println("mod: " + modifiers + ", " + targetType + " and " + fromType);
+ public static boolean isVisible(int modifiers, ResolvedType targetType,
+ ResolvedType fromType) {
+ // System.err.println("mod: " + modifiers + ", " + targetType + " and "
+ // + fromType);
if (Modifier.isPublic(modifiers)) {
return true;
} else if (Modifier.isPrivate(modifiers)) {
- return targetType.getOutermostType().equals(fromType.getOutermostType());
+ return targetType.getOutermostType().equals(
+ fromType.getOutermostType());
} else if (Modifier.isProtected(modifiers)) {
- return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType);
+ return samePackage(targetType, fromType)
+ || targetType.isAssignableFrom(fromType);
} else { // package-visible
return samePackage(targetType, fromType);
}
}
- private static boolean samePackage(ResolvedType targetType, ResolvedType fromType) {
+ private static boolean samePackage(ResolvedType targetType,
+ ResolvedType fromType) {
String p1 = targetType.getPackageName();
String p2 = fromType.getPackageName();
if (p1 == null)
}
/**
- * Checks if the generic type for 'this' and the generic type for 'other' are the same - it can be passed raw or parameterized
- * versions and will just compare the underlying generic type.
+ * Checks if the generic type for 'this' and the generic type for 'other'
+ * are the same - it can be passed raw or parameterized versions and will
+ * just compare the underlying generic type.
*/
private boolean genericTypeEquals(ResolvedType other) {
ResolvedType rt = other;
if (rt.isParameterizedType() || rt.isRawType())
rt.getGenericType();
- if (((isParameterizedType() || isRawType()) && getGenericType().equals(rt)) || (this.equals(other)))
+ if (((isParameterizedType() || isRawType()) && getGenericType().equals(
+ rt))
+ || (this.equals(other)))
return true;
return false;
}
/**
- * Look up the actual occurence of a particular type in the hierarchy for 'this' type. The input is going to be a generic type,
- * and the caller wants to know if it was used in its RAW or a PARAMETERIZED form in this hierarchy.
+ * Look up the actual occurence of a particular type in the hierarchy for
+ * 'this' type. The input is going to be a generic type, and the caller
+ * wants to know if it was used in its RAW or a PARAMETERIZED form in this
+ * hierarchy.
*
* returns null if it can't be found.
*/
- public ResolvedType discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor) {
+ public ResolvedType discoverActualOccurrenceOfTypeInHierarchy(
+ ResolvedType lookingFor) {
if (!lookingFor.isGenericType())
- throw new BCException("assertion failed: method should only be called with generic type, but " + lookingFor + " is "
- + lookingFor.typeKind);
+ throw new BCException(
+ "assertion failed: method should only be called with generic type, but "
+ + lookingFor + " is " + lookingFor.typeKind);
if (this.equals(ResolvedType.OBJECT))
return null;
ResolvedType superI = superIs[i];
if (superI.genericTypeEquals(lookingFor))
return superI;
- ResolvedType checkTheSuperI = superI.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
+ ResolvedType checkTheSuperI = superI
+ .discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
if (checkTheSuperI != null)
return checkTheSuperI;
}
}
/**
- * Called for all type mungers but only does something if they share type variables with a generic type which they target. When
- * this happens this routine will check for the target type in the target hierarchy and 'bind' any type parameters as
- * appropriate. For example, for the ITD "List<T> I<T>.x" against a type like this: "class A implements I<String>" this routine
- * will return a parameterized form of the ITD "List<String> I.x"
+ * Called for all type mungers but only does something if they share type
+ * variables with a generic type which they target. When this happens this
+ * routine will check for the target type in the target hierarchy and 'bind'
+ * any type parameters as appropriate. For example, for the ITD
+ * "List<T> I<T>.x" against a type like this: "class A implements I<String>"
+ * this routine will return a parameterized form of the ITD
+ * "List<String> I.x"
*/
public ConcreteTypeMunger fillInAnyTypeParameters(ConcreteTypeMunger munger) {
boolean debug = false;
ResolvedMember member = munger.getSignature();
if (munger.isTargetTypeParameterized()) {
if (debug)
- System.err.println("Processing attempted parameterization of " + munger + " targetting type " + this);
+ System.err.println("Processing attempted parameterization of "
+ + munger + " targetting type " + this);
if (debug)
- System.err.println(" This type is " + this + " (" + typeKind + ")");
+ System.err.println(" This type is " + this + " (" + typeKind
+ + ")");
// need to tailor this munger instance for the particular target...
if (debug)
- System.err.println(" Signature that needs parameterizing: " + member);
+ System.err.println(" Signature that needs parameterizing: "
+ + member);
// Retrieve the generic type
- ResolvedType onType = world.resolve(member.getDeclaringType()).getGenericType();
- member.resolve(world); // Ensure all parts of the member are resolved
+ ResolvedType onType = world.resolve(member.getDeclaringType())
+ .getGenericType();
+ member.resolve(world); // Ensure all parts of the member are
+ // resolved
if (debug)
- System.err.println(" Actual target ontype: " + onType + " (" + onType.typeKind + ")");
- // quickly find the targettype in the type hierarchy for this type (it will be either RAW or PARAMETERIZED)
+ System.err.println(" Actual target ontype: " + onType + " ("
+ + onType.typeKind + ")");
+ // quickly find the targettype in the type hierarchy for this type
+ // (it will be either RAW or PARAMETERIZED)
ResolvedType actualTarget = discoverActualOccurrenceOfTypeInHierarchy(onType);
if (actualTarget == null)
- throw new BCException("assertion failed: asked " + this + " for occurrence of " + onType + " in its hierarchy??");
+ throw new BCException("assertion failed: asked " + this
+ + " for occurrence of " + onType
+ + " in its hierarchy??");
- // only bind the tvars if its a parameterized type or the raw type (in which case they collapse to bounds) - don't do it
+ // only bind the tvars if its a parameterized type or the raw type
+ // (in which case they collapse to bounds) - don't do it
// for generic types ;)
if (!actualTarget.isGenericType()) {
if (debug)
- System.err.println("Occurrence in " + this + " is actually " + actualTarget + " (" + actualTarget.typeKind
- + ")");
+ System.err.println("Occurrence in " + this
+ + " is actually " + actualTarget + " ("
+ + actualTarget.typeKind + ")");
// parameterize the signature
// ResolvedMember newOne =
- // member.parameterizedWith(actualTarget.getTypeParameters(),onType,actualTarget.isParameterizedType());
+ // member.parameterizedWith(actualTarget.getTypeParameters(),
+ // onType,actualTarget.isParameterizedType());
}
// if (!actualTarget.isRawType())
munger = munger.parameterizedFor(actualTarget);
public void addInterTypeMunger(ConcreteTypeMunger munger) {
ResolvedMember sig = munger.getSignature();
- if (sig == null || munger.getMunger() == null || munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess) {
+ if (sig == null
+ || munger.getMunger() == null
+ || munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess) {
interTypeMungers.add(munger);
return;
}
// ConcreteTypeMunger originalMunger = munger;
- // we will use the 'parameterized' ITD for all the comparisons but we say the original
- // one passed in actually matched as it will be added to the intertype member finder
- // for the target type. It is possible we only want to do this if a generic type
+ // we will use the 'parameterized' ITD for all the comparisons but we
+ // say the original
+ // one passed in actually matched as it will be added to the intertype
+ // member finder
+ // for the target type. It is possible we only want to do this if a
+ // generic type
// is discovered and the tvar is collapsed to a bound?
munger = fillInAnyTypeParameters(munger);
- sig = munger.getSignature(); // possibly changed when type parms filled in
+ sig = munger.getSignature(); // possibly changed when type parms filled
+ // in
- // System.err.println("add: " + munger + " to " + this.getClassName() + " with " + interTypeMungers);
+ // System.err.println("add: " + munger + " to " + this.getClassName() +
+ // " with " + interTypeMungers);
if (sig.getKind() == Member.METHOD) {
- if (!compareToExistingMembers(munger, getMethodsWithoutIterator(false, true) /* getMethods() */))
+ if (!compareToExistingMembers(munger, getMethodsWithoutIterator(
+ false, true) /* getMethods() */))
return;
if (this.isInterface()) {
- if (!compareToExistingMembers(munger, Arrays.asList(world.getCoreType(OBJECT).getDeclaredMethods()).iterator()))
+ if (!compareToExistingMembers(munger, Arrays.asList(
+ world.getCoreType(OBJECT).getDeclaredMethods())
+ .iterator()))
return;
}
} else if (sig.getKind() == Member.FIELD) {
- if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredFields()).iterator()))
+ if (!compareToExistingMembers(munger, Arrays.asList(
+ getDeclaredFields()).iterator()))
return;
} else {
- if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredMethods()).iterator()))
+ if (!compareToExistingMembers(munger, Arrays.asList(
+ getDeclaredMethods()).iterator()))
return;
}
// now compare to existingMungers
for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
ConcreteTypeMunger existingMunger = (ConcreteTypeMunger) i.next();
- if (conflictingSignature(existingMunger.getSignature(), munger.getSignature())) {
- // System.err.println("match " + munger + " with " + existingMunger);
- if (isVisible(munger.getSignature().getModifiers(), munger.getAspectType(), existingMunger.getAspectType())) {
+ if (conflictingSignature(existingMunger.getSignature(), munger
+ .getSignature())) {
+ // System.err.println("match " + munger + " with " +
+ // existingMunger);
+ if (isVisible(munger.getSignature().getModifiers(), munger
+ .getAspectType(), existingMunger.getAspectType())) {
// System.err.println(" is visible");
- int c = compareMemberPrecedence(sig, existingMunger.getSignature());
+ int c = compareMemberPrecedence(sig, existingMunger
+ .getSignature());
if (c == 0) {
- c = getWorld().compareByPrecedenceAndHierarchy(munger.getAspectType(), existingMunger.getAspectType());
+ c = getWorld().compareByPrecedenceAndHierarchy(
+ munger.getAspectType(),
+ existingMunger.getAspectType());
}
// System.err.println(" compare: " + c);
if (c < 0) {
// the existing munger dominates the new munger
- checkLegalOverride(munger.getSignature(), existingMunger.getSignature());
+ checkLegalOverride(munger.getSignature(),
+ existingMunger.getSignature());
return;
} else if (c > 0) {
// the new munger dominates the existing one
- checkLegalOverride(existingMunger.getSignature(), munger.getSignature());
+ checkLegalOverride(existingMunger.getSignature(),
+ munger.getSignature());
i.remove();
break;
} else {
interTypeMungers.add(munger);
}
- private boolean compareToExistingMembers(ConcreteTypeMunger munger, List existingMembersList) {
+ private boolean compareToExistingMembers(ConcreteTypeMunger munger,
+ List existingMembersList) {
return compareToExistingMembers(munger, existingMembersList.iterator());
}
// ??? returning too soon
- private boolean compareToExistingMembers(ConcreteTypeMunger munger, Iterator existingMembers) {
+ private boolean compareToExistingMembers(ConcreteTypeMunger munger,
+ Iterator existingMembers) {
ResolvedMember sig = munger.getSignature();
// ResolvedType declaringAspectType = munger.getAspectType();
- // if (declaringAspectType.isRawType()) declaringAspectType = declaringAspectType.getGenericType();
+ // if (declaringAspectType.isRawType()) declaringAspectType =
+ // declaringAspectType.getGenericType();
// if (declaringAspectType.isGenericType()) {
//
- // ResolvedType genericOnType = getWorld().resolve(sig.getDeclaringType()).getGenericType();
- // ConcreteTypeMunger ctm = munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
+ // ResolvedType genericOnType =
+ // getWorld().resolve(sig.getDeclaringType()).getGenericType();
+ // ConcreteTypeMunger ctm =
+ // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy
+ // (genericOnType));
// sig = ctm.getSignature(); // possible sig change when type
// }
// if (munger.getMunger().hasTypeVariableAliases()) {
// ResolvedType genericOnType =
// getWorld().resolve(sig.getDeclaringType()).getGenericType();
// ConcreteTypeMunger ctm =
- // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
- // sig = ctm.getSignature(); // possible sig change when type parameters filled in
+ // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(
+ // genericOnType));
+ // sig = ctm.getSignature(); // possible sig change when type parameters
+ // filled in
// }
while (existingMembers.hasNext()) {
- ResolvedMember existingMember = (ResolvedMember) existingMembers.next();
+ ResolvedMember existingMember = (ResolvedMember) existingMembers
+ .next();
// don't worry about clashing with bridge methods
if (existingMember.isBridgeMethod())
continue;
- // System.err.println("Comparing munger: "+sig+" with member "+existingMember);
+ // System.err.println("Comparing munger: "+sig+" with member "+
+ // existingMember);
if (conflictingSignature(existingMember, munger.getSignature())) {
- // System.err.println("conflict: existingMember=" + existingMember + " typeMunger=" + munger);
- // System.err.println(munger.getSourceLocation() + ", " + munger.getSignature() + ", " +
+ // System.err.println("conflict: existingMember=" +
+ // existingMember + " typeMunger=" + munger);
+ // System.err.println(munger.getSourceLocation() + ", " +
+ // munger.getSignature() + ", " +
// munger.getSignature().getSourceLocation());
- if (isVisible(existingMember.getModifiers(), this, munger.getAspectType())) {
+ if (isVisible(existingMember.getModifiers(), this, munger
+ .getAspectType())) {
int c = compareMemberPrecedence(sig, existingMember);
// System.err.println(" c: " + c);
if (c < 0) {
// existingMember dominates munger
- checkLegalOverride(munger.getSignature(), existingMember);
+ checkLegalOverride(munger.getSignature(),
+ existingMember);
return false;
} else if (c > 0) {
// munger dominates existingMember
- checkLegalOverride(existingMember, munger.getSignature());
+ checkLegalOverride(existingMember, munger
+ .getSignature());
// interTypeMungers.add(munger);
// ??? might need list of these overridden abstracts
continue;
} else {
// bridge methods can differ solely in return type.
- // FIXME this whole method seems very hokey - unaware of covariance/varargs/bridging - it
+ // FIXME this whole method seems very hokey - unaware of
+ // covariance/varargs/bridging - it
// could do with a rewrite !
- boolean sameReturnTypes = (existingMember.getReturnType().equals(sig.getReturnType()));
+ boolean sameReturnTypes = (existingMember
+ .getReturnType().equals(sig.getReturnType()));
if (sameReturnTypes) {
- // pr206732 - if the existingMember is due to a previous application of this same ITD (which can
- // happen if this is a binary type being brought in from the aspectpath). The 'better' fix is
- // to recognize it is from the aspectpath at a higher level and dont do this, but that is rather
+ // pr206732 - if the existingMember is due to a
+ // previous application of this same ITD (which can
+ // happen if this is a binary type being brought in
+ // from the aspectpath). The 'better' fix is
+ // to recognize it is from the aspectpath at a
+ // higher level and dont do this, but that is rather
// more work.
boolean isDuplicateOfPreviousITD = false;
- ResolvedType declaringRt = existingMember.getDeclaringType().resolve(world);
+ ResolvedType declaringRt = existingMember
+ .getDeclaringType().resolve(world);
WeaverStateInfo wsi = declaringRt.getWeaverState();
if (wsi != null) {
- List mungersAffectingThisType = wsi.getTypeMungers(declaringRt);
+ List mungersAffectingThisType = wsi
+ .getTypeMungers(declaringRt);
if (mungersAffectingThisType != null) {
- for (Iterator iterator = mungersAffectingThisType.iterator(); iterator.hasNext()
+ for (Iterator iterator = mungersAffectingThisType
+ .iterator(); iterator.hasNext()
&& !isDuplicateOfPreviousITD;) {
- ConcreteTypeMunger ctMunger = (ConcreteTypeMunger) iterator.next();
- // relatively crude check - is the ITD for the same as the existingmember and does it come
+ ConcreteTypeMunger ctMunger = (ConcreteTypeMunger) iterator
+ .next();
+ // relatively crude check - is the ITD
+ // for the same as the existingmember
+ // and does it come
// from the same aspect
- if (ctMunger.getSignature().equals(existingMember)
- && ctMunger.aspectType.equals(munger.getAspectType())) {
+ if (ctMunger.getSignature().equals(
+ existingMember)
+ && ctMunger.aspectType
+ .equals(munger
+ .getAspectType())) {
isDuplicateOfPreviousITD = true;
}
}
}
}
if (!isDuplicateOfPreviousITD) {
- getWorld().getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, munger
- .getAspectType().getName(), existingMember), munger.getSourceLocation()));
+ getWorld()
+ .getMessageHandler()
+ .handleMessage(
+ MessageUtil
+ .error(
+ WeaverMessages
+ .format(
+ WeaverMessages.ITD_MEMBER_CONFLICT,
+ munger
+ .getAspectType()
+ .getName(),
+ existingMember),
+ munger
+ .getSourceLocation()));
}
}
}
- } else if (isDuplicateMemberWithinTargetType(existingMember, this, sig)) {
+ } else if (isDuplicateMemberWithinTargetType(existingMember,
+ this, sig)) {
getWorld().getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, munger.getAspectType()
- .getName(), existingMember), munger.getSourceLocation()));
+ MessageUtil
+ .error(WeaverMessages.format(
+ WeaverMessages.ITD_MEMBER_CONFLICT,
+ munger.getAspectType().getName(),
+ existingMember), munger
+ .getSourceLocation()));
}
// return;
return true;
}
- // we know that the member signature matches, but that the member in the target type is not visible to the aspect.
- // this may still be disallowed if it would result in two members within the same declaring type with the same
- // signature AND more than one of them is concrete AND they are both visible within the target type.
- private boolean isDuplicateMemberWithinTargetType(ResolvedMember existingMember, ResolvedType targetType,
+ // we know that the member signature matches, but that the member in the
+ // target type is not visible to the aspect.
+ // this may still be disallowed if it would result in two members within the
+ // same declaring type with the same
+ // signature AND more than one of them is concrete AND they are both visible
+ // within the target type.
+ private boolean isDuplicateMemberWithinTargetType(
+ ResolvedMember existingMember, ResolvedType targetType,
ResolvedMember itdMember) {
if ((existingMember.isAbstract() || itdMember.isAbstract()))
return false;
if (itdMember.isPublic())
return true;
// must be in same package to be visible then...
- if (!targetType.getPackageName().equals(itdMember.getDeclaringType().getPackageName()))
+ if (!targetType.getPackageName().equals(
+ itdMember.getDeclaringType().getPackageName()))
return false;
- // trying to put two members with the same signature into the exact same type..., and both visible in that type.
+ // trying to put two members with the same signature into the exact same
+ // type..., and both visible in that type.
return true;
}
/**
- * @return true if the override is legal note: calling showMessage with two locations issues TWO messages, not ONE message with
- * an additional source location.
+ * @return true if the override is legal note: calling showMessage with two
+ * locations issues TWO messages, not ONE message with an additional
+ * source location.
*/
- public boolean checkLegalOverride(ResolvedMember parent, ResolvedMember child) {
- // System.err.println("check: " + child.getDeclaringType() + " overrides " + parent.getDeclaringType());
+ public boolean checkLegalOverride(ResolvedMember parent,
+ ResolvedMember child) {
+ // System.err.println("check: " + child.getDeclaringType() +
+ // " overrides " + parent.getDeclaringType());
if (Modifier.isFinal(parent.getModifiers())) {
- world.showMessage(Message.ERROR, WeaverMessages.format(WeaverMessages.CANT_OVERRIDE_FINAL_MEMBER, parent), child
+ world.showMessage(Message.ERROR, WeaverMessages.format(
+ WeaverMessages.CANT_OVERRIDE_FINAL_MEMBER, parent), child
.getSourceLocation(), null);
return false;
}
if (world.isInJava5Mode() && parent.getKind() == Member.METHOD) {
// Look at the generic types when doing this comparison
- ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world);
- ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world);
- incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
- // For debug, uncomment this bit and we'll repeat the check - stick a breakpoint on the call
+ ResolvedType rtParentReturnType = parent.resolve(world)
+ .getGenericReturnType().resolve(world);
+ ResolvedType rtChildReturnType = child.resolve(world)
+ .getGenericReturnType().resolve(world);
+ incompatibleReturnTypes = !rtParentReturnType
+ .isAssignableFrom(rtChildReturnType);
+ // For debug, uncomment this bit and we'll repeat the check - stick
+ // a breakpoint on the call
// if (incompatibleReturnTypes) {
- // incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
+ // incompatibleReturnTypes =
+ // !rtParentReturnType.isAssignableFrom(rtChildReturnType);
// }
} else {
- incompatibleReturnTypes = !parent.getReturnType().equals(child.getReturnType());
+ incompatibleReturnTypes = !parent.getReturnType().equals(
+ child.getReturnType());
}
if (incompatibleReturnTypes) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_RETURN_TYPE_MISMATCH, parent, child), child
- .getSourceLocation(), parent.getSourceLocation());
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.ITD_RETURN_TYPE_MISMATCH, parent, child),
+ child.getSourceLocation(), parent.getSourceLocation());
return false;
}
if (parent.getKind() == Member.POINTCUT) {
UnresolvedType[] pTypes = parent.getParameterTypes();
UnresolvedType[] cTypes = child.getParameterTypes();
if (!Arrays.equals(pTypes, cTypes)) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_PARAM_TYPE_MISMATCH, parent, child),
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.ITD_PARAM_TYPE_MISMATCH, parent, child),
child.getSourceLocation(), parent.getSourceLocation());
return false;
}
}
- // System.err.println("check: " + child.getModifiers() + " more visible " + parent.getModifiers());
+ // System.err.println("check: " + child.getModifiers() +
+ // " more visible " + parent.getModifiers());
if (isMoreVisible(parent.getModifiers(), child.getModifiers())) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_VISIBILITY_REDUCTION, parent, child), child
- .getSourceLocation(), parent.getSourceLocation());
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.ITD_VISIBILITY_REDUCTION, parent, child),
+ child.getSourceLocation(), parent.getSourceLocation());
return false;
}
// check declared exceptions
ResolvedType[] childExceptions = world.resolve(child.getExceptions());
ResolvedType[] parentExceptions = world.resolve(parent.getExceptions());
- ResolvedType runtimeException = world.resolve("java.lang.RuntimeException");
+ ResolvedType runtimeException = world
+ .resolve("java.lang.RuntimeException");
ResolvedType error = world.resolve("java.lang.Error");
outer: for (int i = 0, leni = childExceptions.length; i < leni; i++) {
// this message is now better handled my MethodVerifier in JDT core.
// world.showMessage(IMessage.ERROR,
- // WeaverMessages.format(WeaverMessages.ITD_DOESNT_THROW,childExceptions[i].getName()),
+ // WeaverMessages.format(WeaverMessages.ITD_DOESNT_THROW,
+ // childExceptions[i].getName()),
// child.getSourceLocation(), null);
return false;
}
if (parent.isStatic() && !child.isStatic()) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERRIDDEN_STATIC, child, parent), child
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.ITD_OVERRIDDEN_STATIC, child, parent), child
.getSourceLocation(), null);
return false;
} else if (child.isStatic() && !parent.isStatic()) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERIDDING_STATIC, child, parent), child
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.ITD_OVERIDDING_STATIC, child, parent), child
.getSourceLocation(), null);
return false;
}
private int compareMemberPrecedence(ResolvedMember m1, ResolvedMember m2) {
// if (!m1.getReturnType().equals(m2.getReturnType())) return 0;
- // need to allow for the special case of 'clone' - which is like abstract but is
- // not marked abstract. The code below this next line seems to make assumptions
+ // need to allow for the special case of 'clone' - which is like
+ // abstract but is
+ // not marked abstract. The code below this next line seems to make
+ // assumptions
// about what will have gotten through the compiler based on the normal
// java rules. clone goes against these...
if (m2.isProtected() && m2.getName().charAt(0) == 'c') {
UnresolvedType declaring = m2.getDeclaringType();
if (declaring != null) {
- if (declaring.getName().equals("java.lang.Object") && m2.getName().equals("clone"))
+ if (declaring.getName().equals("java.lang.Object")
+ && m2.getName().equals("clone"))
return +1;
}
}
return (0 == (i & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)));
}
- private void interTypeConflictError(ConcreteTypeMunger m1, ConcreteTypeMunger m2) {
+ private void interTypeConflictError(ConcreteTypeMunger m1,
+ ConcreteTypeMunger m2) {
// XXX this works only if we ignore separate compilation issues
// XXX dual errors possible if (this instanceof BcelObjectType) return;
// System.err.println("conflict at " + m2.getSourceLocation());
getWorld().showMessage(
IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_CONFLICT, m1.getAspectType().getName(), m2.getSignature(), m2
- .getAspectType().getName()), m2.getSourceLocation(), getSourceLocation());
+ WeaverMessages.format(WeaverMessages.ITD_CONFLICT, m1
+ .getAspectType().getName(), m2.getSignature(), m2
+ .getAspectType().getName()), m2.getSourceLocation(),
+ getSourceLocation());
}
public ResolvedMember lookupSyntheticMember(Member member) {
// Handling members for the new array join point
if (world.isJoinpointArrayConstructionEnabled() && this.isArray()) {
if (member.getKind() == Member.CONSTRUCTOR) {
- ResolvedMemberImpl ret = new ResolvedMemberImpl(Member.CONSTRUCTOR, this, Modifier.PUBLIC, ResolvedType.VOID,
- "<init>", world.resolve(member.getParameterTypes()));
+ ResolvedMemberImpl ret = new ResolvedMemberImpl(
+ Member.CONSTRUCTOR, this, Modifier.PUBLIC,
+ ResolvedType.VOID, "<init>", world.resolve(member
+ .getParameterTypes()));
return ret;
}
}
- // if (this.getSuperclass() != ResolvedType.OBJECT && this.getSuperclass() != null) {
+ // if (this.getSuperclass() != ResolvedType.OBJECT &&
+ // this.getSuperclass() != null) {
// return getSuperclass().lookupSyntheticMember(member);
// }
return false;
// check that I'm truly the topmost implementor
if (this.getSuperclass().isMissing())
- return true; // we don't know anything about supertype, and it can't be exposed to weaver
+ return true; // we don't know anything about supertype, and it can't
+ // be exposed to weaver
if (interfaceType.isAssignableFrom(this.getSuperclass(), true)) {
return false;
}
if (!interfaceType.isAssignableFrom(this))
return null;
// Check if my super class is an implementor?
- ResolvedType higherType = this.getSuperclass().getTopmostImplementor(interfaceType);
+ ResolvedType higherType = this.getSuperclass().getTopmostImplementor(
+ interfaceType);
if (higherType != null)
return higherType;
return this;
if (getSuperclass() != null)
ret.addAll(getSuperclass().getExposedPointcuts());
- for (Iterator i = Arrays.asList(getDeclaredInterfaces()).iterator(); i.hasNext();) {
+ for (Iterator i = Arrays.asList(getDeclaredInterfaces()).iterator(); i
+ .hasNext();) {
ResolvedType t = (ResolvedType) i.next();
- addPointcutsResolvingConflicts(ret, Arrays.asList(t.getDeclaredPointcuts()), false);
+ addPointcutsResolvingConflicts(ret, Arrays.asList(t
+ .getDeclaredPointcuts()), false);
}
- addPointcutsResolvingConflicts(ret, Arrays.asList(getDeclaredPointcuts()), true);
+ addPointcutsResolvingConflicts(ret, Arrays
+ .asList(getDeclaredPointcuts()), true);
for (Iterator i = ret.iterator(); i.hasNext();) {
- ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition) i.next();
+ ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition) i
+ .next();
// System.err.println("looking at: " + inherited + " in " + this);
- // System.err.println(" " + inherited.isAbstract() + " in " + this.isAbstract());
+ // System.err.println(" " + inherited.isAbstract() +
+ // " in " + this.isAbstract());
if (inherited.isAbstract()) {
if (!this.isAbstract()) {
- getWorld().showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINCUT_NOT_CONCRETE, inherited, this.getName()),
- inherited.getSourceLocation(), this.getSourceLocation());
+ getWorld().showMessage(
+ IMessage.ERROR,
+ WeaverMessages.format(
+ WeaverMessages.POINCUT_NOT_CONCRETE,
+ inherited, this.getName()),
+ inherited.getSourceLocation(),
+ this.getSourceLocation());
}
}
}
return ret;
}
- private void addPointcutsResolvingConflicts(List acc, List added, boolean isOverriding) {
+ private void addPointcutsResolvingConflicts(List acc, List added,
+ boolean isOverriding) {
for (Iterator i = added.iterator(); i.hasNext();) {
- ResolvedPointcutDefinition toAdd = (ResolvedPointcutDefinition) i.next();
+ ResolvedPointcutDefinition toAdd = (ResolvedPointcutDefinition) i
+ .next();
// System.err.println("adding: " + toAdd);
for (Iterator j = acc.iterator(); j.hasNext();) {
- ResolvedPointcutDefinition existing = (ResolvedPointcutDefinition) j.next();
+ ResolvedPointcutDefinition existing = (ResolvedPointcutDefinition) j
+ .next();
if (existing == toAdd)
continue;
- if (!isVisible(existing.getModifiers(), existing.getDeclaringType().resolve(getWorld()), this)) {
- // if they intended to override it but it is not visible, give them a nicer message
- if (existing.isAbstract() && conflictingSignature(existing, toAdd)) {
+ if (!isVisible(existing.getModifiers(), existing
+ .getDeclaringType().resolve(getWorld()), this)) {
+ // if they intended to override it but it is not visible,
+ // give them a nicer message
+ if (existing.isAbstract()
+ && conflictingSignature(existing, toAdd)) {
getWorld().showMessage(
IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINTCUT_NOT_VISIBLE, existing.getDeclaringType().getName()
- + "." + existing.getName() + "()", this.getName()), toAdd.getSourceLocation(), null);
+ WeaverMessages.format(
+ WeaverMessages.POINTCUT_NOT_VISIBLE,
+ existing.getDeclaringType().getName()
+ + "." + existing.getName()
+ + "()", this.getName()),
+ toAdd.getSourceLocation(), null);
j.remove();
}
continue;
checkLegalOverride(existing, toAdd);
j.remove();
} else {
- getWorld().showMessage(
- IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.CONFLICTING_INHERITED_POINTCUTS, this.getName()
- + toAdd.getSignature()), existing.getSourceLocation(), toAdd.getSourceLocation());
+ getWorld()
+ .showMessage(
+ IMessage.ERROR,
+ WeaverMessages
+ .format(
+ WeaverMessages.CONFLICTING_INHERITED_POINTCUTS,
+ this.getName()
+ + toAdd
+ .getSignature()),
+ existing.getSourceLocation(),
+ toAdd.getSourceLocation());
j.remove();
}
}
}
/**
- * Overridden by ReferenceType to return a sensible answer for parameterized and raw types.
+ * Overridden by ReferenceType to return a sensible answer for parameterized
+ * and raw types.
*
* @return
*/
public ResolvedType getGenericType() {
if (!(isParameterizedType() || isRawType()))
- throw new BCException("The type " + getBaseName() + " is not parameterized or raw - it has no generic type");
+ throw new BCException("The type " + getBaseName()
+ + " is not parameterized or raw - it has no generic type");
return null;
}
public ResolvedType parameterizedWith(UnresolvedType[] typeParameters) {
if (!(isGenericType() || isParameterizedType()))
return this;
- return TypeFactory.createParameterizedType(this.getGenericType(), typeParameters, getWorld());
+ return TypeFactory.createParameterizedType(this.getGenericType(),
+ typeParameters, getWorld());
}
/**
- * Iff I am a parameterized type, and any of my parameters are type variable references, return a version with those type
- * parameters replaced in accordance with the passed bindings.
+ * Iff I am a parameterized type, and any of my parameters are type variable
+ * references, return a version with those type parameters replaced in
+ * accordance with the passed bindings.
*/
public UnresolvedType parameterize(Map typeBindings) {
if (!isParameterizedType())
- return this;// throw new IllegalStateException("Can't parameterize a type that is not a parameterized type");
+ return this;// throw new IllegalStateException(
+ // "Can't parameterize a type that is not a parameterized type"
+ // );
boolean workToDo = false;
for (int i = 0; i < typeParameters.length; i++) {
- if (typeParameters[i].isTypeVariableReference() || (typeParameters[i] instanceof BoundedReferenceType)) {
+ if (typeParameters[i].isTypeVariableReference()
+ || (typeParameters[i] instanceof BoundedReferenceType)) {
workToDo = true;
}
}
newTypeParams[i] = typeParameters[i];
if (newTypeParams[i].isTypeVariableReference()) {
TypeVariableReferenceType tvrt = (TypeVariableReferenceType) newTypeParams[i];
- UnresolvedType binding = (UnresolvedType) typeBindings.get(tvrt.getTypeVariable().getName());
+ UnresolvedType binding = (UnresolvedType) typeBindings
+ .get(tvrt.getTypeVariable().getName());
if (binding != null)
newTypeParams[i] = binding;
} else if (newTypeParams[i] instanceof BoundedReferenceType) {
// brType.parameterize(typeBindings)
}
}
- return TypeFactory.createParameterizedType(getGenericType(), newTypeParams, getWorld());
+ return TypeFactory.createParameterizedType(getGenericType(),
+ newTypeParams, getWorld());
}
}
// parameterizedSuperTypes = (ResolvedType[]) accumulatedTypes.toArray(ret);
// return parameterizedSuperTypes;
// }
- // private void accumulateParameterizedSuperTypes(ResolvedType forType, List parameterizedTypeList) {
+ // private void accumulateParameterizedSuperTypes(ResolvedType forType, List
+ // parameterizedTypeList) {
// if (forType.isParameterizedType()) {
// parameterizedTypeList.add(forType);
// }
// if (forType.getSuperclass() != null) {
- // accumulateParameterizedSuperTypes(forType.getSuperclass(), parameterizedTypeList);
+ // accumulateParameterizedSuperTypes(forType.getSuperclass(),
+ // parameterizedTypeList);
// }
// ResolvedType[] interfaces = forType.getDeclaredInterfaces();
// for (int i = 0; i < interfaces.length; i++) {
* @return true if assignable to java.lang.Exception
*/
public boolean isException() {
- return (world.getCoreType(UnresolvedType.JAVA_LANG_EXCEPTION).isAssignableFrom(this));
+ return (world.getCoreType(UnresolvedType.JAVA_LANG_EXCEPTION)
+ .isAssignableFrom(this));
}
/**
- * @return true if it is an exception and it is a checked one, false otherwise.
+ * @return true if it is an exception and it is a checked one, false
+ * otherwise.
*/
public boolean isCheckedException() {
if (!isException())
return false;
- if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION).isAssignableFrom(this))
+ if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION)
+ .isAssignableFrom(this))
return false;
return true;
}
/**
- * Determines if variables of this type could be assigned values of another with lots of help. java.lang.Object is convertable
- * from all types. A primitive type is convertable from X iff it's assignable from X. A reference type is convertable from X iff
- * it's coerceable from X. In other words, X isConvertableFrom Y iff the compiler thinks that _some_ value of Y could be
- * assignable to a variable of type X without loss of precision.
+ * Determines if variables of this type could be assigned values of another
+ * with lots of help. java.lang.Object is convertable from all types. A
+ * primitive type is convertable from X iff it's assignable from X. A
+ * reference type is convertable from X iff it's coerceable from X. In other
+ * words, X isConvertableFrom Y iff the compiler thinks that _some_ value of
+ * Y could be assignable to a variable of type X without loss of precision.
*
- * @param other the other type
- * @param world the {@link World} in which the possible assignment should be checked.
- * @return true iff variables of this type could be assigned values of other with possible conversion
+ * @param other
+ * the other type
+ * @param world
+ * the {@link World} in which the possible assignment should be
+ * checked.
+ * @return true iff variables of this type could be assigned values of other
+ * with possible conversion
*/
public final boolean isConvertableFrom(ResolvedType other) {
// // version from TypeX
// if (this.equals(OBJECT)) return true;
- // if (this.isPrimitiveType() || other.isPrimitiveType()) return this.isAssignableFrom(other);
+ // if (this.isPrimitiveType() || other.isPrimitiveType()) return
+ // this.isAssignableFrom(other);
// return this.isCoerceableFrom(other);
//
if (this.equals(OBJECT))
return true;
if (world.isInJava5Mode()) {
- if (this.isPrimitiveType() ^ other.isPrimitiveType()) { // If one is primitive and the other isnt
- if (validBoxing.contains(this.getSignature() + other.getSignature()))
+ if (this.isPrimitiveType() ^ other.isPrimitiveType()) { // If one is
+ // primitive
+ // and the
+ // other
+ // isnt
+ if (validBoxing.contains(this.getSignature()
+ + other.getSignature()))
return true;
}
}
}
/**
- * Determines if the variables of this type could be assigned values of another type without casting. This still allows for
- * assignment conversion as per JLS 2ed 5.2. For object types, this means supertypeOrEqual(THIS, OTHER).
+ * Determines if the variables of this type could be assigned values of
+ * another type without casting. This still allows for assignment conversion
+ * as per JLS 2ed 5.2. For object types, this means supertypeOrEqual(THIS,
+ * OTHER).
*
- * @param other the other type
- * @param world the {@link World} in which the possible assignment should be checked.
- * @return true iff variables of this type could be assigned values of other without casting
- * @throws NullPointerException if other is null
+ * @param other
+ * the other type
+ * @param world
+ * the {@link World} in which the possible assignment should be
+ * checked.
+ * @return true iff variables of this type could be assigned values of other
+ * without casting
+ * @throws NullPointerException
+ * if other is null
*/
public abstract boolean isAssignableFrom(ResolvedType other);
- public abstract boolean isAssignableFrom(ResolvedType other, boolean allowMissing);
+ public abstract boolean isAssignableFrom(ResolvedType other,
+ boolean allowMissing);
/**
- * Determines if values of another type could possibly be cast to this type. The rules followed are from JLS 2ed 5.5,
- * "Casting Conversion". <p/>
+ * Determines if values of another type could possibly be cast to this type.
+ *
The rules followed are from JLS 2ed 5.5, "Casting Conversion". <p/>
* <p>
- * This method should be commutative, i.e., for all UnresolvedType a, b and all World w: <p/> <blockquote>
+ * This method should be commutative, i.e., for all UnresolvedType a, b and
+ * all World w: <p/> <blockquote>
*
* <pre>
* a.isCoerceableFrom(b, w) == b.isCoerceableFrom(a, w)
*
* </blockquote>
*
- * @param other the other type
- * @param world the {@link World} in which the possible coersion should be checked.
+ * @param other
+ * the other type
+ * @param world
+ * the {@link World} in which the possible coersion should be
+ * checked.
* @return true iff values of other could possibly be cast to this type.
- * @throws NullPointerException if other is null.
+ * @throws NullPointerException
+ * if other is null.
*/
public abstract boolean isCoerceableFrom(ResolvedType other);
}
public String getSignatureForAttribute() {
- return signature; // Assume if this is being called that it is for a simple type (eg. void, int, etc)
+ return signature; // Assume if this is being called that it is for a
+ // simple type (eg. void, int, etc)
}
private FuzzyBoolean parameterizedWithTypeVariable = FuzzyBoolean.MAYBE;
/**
- * return true if the parameterization of this type includes a member type variable. Member type variables occur in generic
- * methods/ctors.
+ * return true if the parameterization of this type includes a member type
+ * variable. Member type variables occur in generic methods/ctors.
*/
public boolean isParameterizedWithTypeVariable() {
// MAYBE means we haven't worked it out yet...
ResolvedType aType = (ResolvedType) typeParameters[i];
if (aType.isTypeVariableReference()
// Changed according to the problems covered in bug 222648
- // Don't care what kind of type variable - the fact that there is one
- // at all means we can't risk caching it against we get confused later
- // by another variation of the parameterization that just happens to
+ // Don't care what kind of type variable - the fact that there
+ // is one
+ // at all means we can't risk caching it against we get confused
+ // later
+ // by another variation of the parameterization that just
+ // happens to
// use the same type variable name
- // assume the worst - if its definetly not a type declared one, it could be anything
- // && ((TypeVariableReference)aType).getTypeVariable().getDeclaringElementKind()!=TypeVariable.TYPE
+ // assume the worst - if its definetly not a type declared one,
+ // it could be anything
+ // && ((TypeVariableReference)aType).getTypeVariable().
+ // getDeclaringElementKind()!=TypeVariable.TYPE
) {
parameterizedWithTypeVariable = FuzzyBoolean.YES;
return true;
boolean b = false;
UnresolvedType upperBound = boundedRT.getUpperBound();
if (upperBound.isParameterizedType()) {
- b = ((ResolvedType) upperBound).isParameterizedWithTypeVariable();
+ b = ((ResolvedType) upperBound)
+ .isParameterizedWithTypeVariable();
} else if (upperBound.isTypeVariableReference()
- && ((TypeVariableReference) upperBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
+ && ((TypeVariableReference) upperBound)
+ .getTypeVariable()
+ .getDeclaringElementKind() == TypeVariable.METHOD) {
b = true;
}
if (b) {
boolean b = false;
UnresolvedType lowerBound = boundedRT.getLowerBound();
if (lowerBound.isParameterizedType()) {
- b = ((ResolvedType) lowerBound).isParameterizedWithTypeVariable();
+ b = ((ResolvedType) lowerBound)
+ .isParameterizedWithTypeVariable();
} else if (lowerBound.isTypeVariableReference()
- && ((TypeVariableReference) lowerBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
+ && ((TypeVariableReference) lowerBound)
+ .getTypeVariable()
+ .getDeclaringElementKind() == TypeVariable.METHOD) {
b = true;
}
if (b) {
protected Map getAjMemberParameterizationMap() {
Map myMap = getMemberParameterizationMap();
if (myMap.isEmpty()) {
- // might extend a parameterized aspect that we also need to consider...
+ // might extend a parameterized aspect that we also need to
+ // consider...
if (getSuperclass() != null)
return getSuperclass().getAjMemberParameterizationMap();
}
}
/**
- * Returns the path to the jar or class file from which this binary aspect came or null if not a binary aspect
+ * Returns the path to the jar or class file from which this binary aspect
+ * came or null if not a binary aspect
*/
public String getBinaryPath() {
return binaryPath;
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2008 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
+ *
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This type represents the weavers abstraction of an annotation - it is not tied to any underlying BCI toolkit. The weaver actualy
+ * handles these through AnnotationX wrapper objects - until we start transforming the BCEL annotations into this form (expensive)
+ * or offer a clever visitor mechanism over the BCEL annotation stuff that builds these annotation types directly.
+ *
+ * @author AndyClement
+ */
+public class StandardAnnotation extends AbstractAnnotationAJ {
+
+ private final boolean isRuntimeVisible;
+
+ private List /* of AnnotationNVPair */nvPairs = null;
+
+ public StandardAnnotation(ResolvedType type, boolean isRuntimeVisible) {
+ super(type);
+ this.isRuntimeVisible = isRuntimeVisible;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isRuntimeVisible() {
+ return isRuntimeVisible;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public String stringify() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("@").append(type.getClassName());
+ if (hasNameValuePairs()) {
+ sb.append("(");
+ for (Iterator iter = nvPairs.iterator(); iter.hasNext();) {
+ AnnotationNameValuePair element = (AnnotationNameValuePair) iter.next();
+ sb.append(element.stringify());
+ }
+ sb.append(")");
+ }
+ return sb.toString();
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("ANNOTATION [" + getTypeSignature() + "] [" + (isRuntimeVisible ? "runtimeVisible" : "runtimeInvisible") + "] [");
+ if (nvPairs != null) {
+ for (Iterator iter = nvPairs.iterator(); iter.hasNext();) {
+ AnnotationNameValuePair element = (AnnotationNameValuePair) iter.next();
+ sb.append(element.toString());
+ if (iter.hasNext())
+ sb.append(",");
+ }
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNamedValue(String n) {
+ if (nvPairs == null)
+ return false;
+ for (int i = 0; i < nvPairs.size(); i++) {
+ AnnotationNameValuePair pair = (AnnotationNameValuePair) nvPairs.get(i);
+ if (pair.getName().equals(n))
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNameValuePair(String n, String v) {
+ if (nvPairs == null)
+ return false;
+ for (int i = 0; i < nvPairs.size(); i++) {
+ AnnotationNameValuePair pair = (AnnotationNameValuePair) nvPairs.get(i);
+ if (pair.getName().equals(n)) {
+ if (pair.getValue().stringify().equals(v))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Set /* <String> */getTargets() {
+ if (!type.equals(UnresolvedType.AT_TARGET)) {
+ return Collections.EMPTY_SET;
+ }
+ AnnotationNameValuePair nvp = (AnnotationNameValuePair) nvPairs.get(0);
+ ArrayAnnotationValue aav = (ArrayAnnotationValue) nvp.getValue();
+ AnnotationValue[] avs = aav.getValues();
+ Set targets = new HashSet();
+ for (int i = 0; i < avs.length; i++) {
+ AnnotationValue value = avs[i];
+ targets.add(value.stringify());
+ }
+ return targets;
+ }
+
+ public List getNameValuePairs() {
+ return nvPairs;
+ }
+
+ public boolean hasNameValuePairs() {
+ return nvPairs != null && nvPairs.size() != 0;
+ }
+
+ public void addNameValuePair(AnnotationNameValuePair pair) {
+ if (nvPairs == null) {
+ nvPairs = new ArrayList();
+ }
+ nvPairs.add(pair);
+ }
+
+}
import org.aspectj.apache.bcel.generic.InstructionFactory;
import org.aspectj.apache.bcel.generic.InstructionList;
import org.aspectj.apache.bcel.generic.Type;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.Member;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;
}
public void appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) {
- // Only possible to do annotation field value extraction at MethodExecution
+ // Only possible to do annotation field value extraction at
+ // MethodExecution
if (annoAccessor.getKind() != Shadow.MethodExecution) {
return;
}
String annotationOfInterestSignature = annoAccessor.getType().getSignature();
- // So we have an entity that has an annotation on and within it is the value we want
+ // So we have an entity that has an annotation on and within it is the
+ // value we want
Member holder = annoAccessor.getMember();
- AnnotationX[] annos = holder.getAnnotations();
+ AnnotationAJ[] annos = holder.getAnnotations();
for (int i = 0; i < annos.length; i++) {
- AnnotationGen annotation = annos[i].getBcelAnnotation();
+ AnnotationGen annotation = ((BcelAnnotation) annos[i]).getBcelAnnotation();
if (annotation.getTypeSignature().equals(annotationOfInterestSignature)) {
List vals = annotation.getValues();
boolean doneAndDusted = false;
for (int ii = 0; ii < annotationFields.length; ii++) {
if (annotationFields[ii].getType().equals(annoFieldOfInterest)) {
String dvalue = annotationFields[ii].getAnnotationDefaultValue();
- // form will be LBLAHBLAHBLAH;X where X is the field within X
+ // form will be LBLAHBLAHBLAH;X where X is the field
+ // within X
String typename = dvalue.substring(0, dvalue.lastIndexOf(';') + 1);
String field = dvalue.substring(dvalue.lastIndexOf(';') + 1);
ResolvedType rt = toType.getWorld().resolve(UnresolvedType.forSignature(typename));
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2008 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
+ *
+ * ******************************************************************/
+package org.aspectj.weaver.bcel;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValueGen;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.classfile.annotation.EnumElementValueGen;
+import org.aspectj.weaver.AbstractAnnotationAJ;
+import org.aspectj.weaver.UnresolvedType;
+import org.aspectj.weaver.World;
+
+/**
+ * Wraps a Bcel Annotation object and uses it to answer AnnotationAJ method calls. This is cheaper than translating all Bcel
+ * annotations into AnnotationAJ objects.
+ *
+ * @author AndyClement
+ */
+public class BcelAnnotation extends AbstractAnnotationAJ {
+
+ private final AnnotationGen bcelAnnotation;
+
+ public BcelAnnotation(AnnotationGen theBcelAnnotation, World world) {
+ super(UnresolvedType.forSignature(theBcelAnnotation.getTypeSignature()).resolve(world));
+ this.bcelAnnotation = theBcelAnnotation;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Set /* of String */getTargets() {
+ if (!type.equals(UnresolvedType.AT_TARGET)) {
+ return Collections.EMPTY_SET;
+ }
+ List values = bcelAnnotation.getValues();
+ ElementNameValuePairGen envp = (ElementNameValuePairGen) values.get(0);
+ ArrayElementValueGen aev = (ArrayElementValueGen) envp.getValue();
+ ElementValueGen[] evs = aev.getElementValuesArray();
+ Set targets = new HashSet();
+ for (int i = 0; i < evs.length; i++) {
+ EnumElementValueGen ev = (EnumElementValueGen) evs[i];
+ targets.add(ev.getEnumValueString());
+ }
+ return targets;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNameValuePair(String name, String value) {
+ return bcelAnnotation.hasNameValuePair(name, value);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNamedValue(String name) {
+ return bcelAnnotation.hasNamedValue(name);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public String stringify() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("@").append(type.getClassName());
+ List values = bcelAnnotation.getValues();
+ if (values != null && values.size() != 0) {
+ sb.append("(");
+ for (Iterator iterator = values.iterator(); iterator.hasNext();) {
+ ElementNameValuePairGen nvPair = (ElementNameValuePairGen) iterator.next();
+ sb.append(nvPair.getNameString()).append("=").append(nvPair.getValue().stringifyValue());
+ }
+ sb.append(")");
+ }
+ return sb.toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isRuntimeVisible() {
+ return this.bcelAnnotation.isRuntimeVisible();
+ }
+
+ /**
+ * @return return the real bcel annotation being wrapped
+ */
+ public AnnotationGen getBcelAnnotation() {
+ return bcelAnnotation;
+ }
+
+}
import org.aspectj.util.PartialOrder;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AsmRelationshipProvider;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ConcreteTypeMunger;
*/
public static boolean weave(BcelWorld world, LazyClassGen clazz, List shadowMungers, List typeMungers, List lateTypeMungers) {
boolean b = new BcelClassWeaver(world, clazz, shadowMungers, typeMungers, lateTypeMungers).weave();
- // System.out.println(clazz.getClassName() + ", " + clazz.getType().getWeaverState());
+ // System.out.println(clazz.getClassName() + ", " +
+ // clazz.getType().getWeaverState());
// clazz.print();
return b;
}
private static boolean inReweavableMode = false;
private List addedSuperInitializersAsList = null; // List<IfaceInitList>
- private final Map addedSuperInitializers = new HashMap(); // Interface -> IfaceInitList
+ private final Map addedSuperInitializers = new HashMap(); // Interface ->
+ // IfaceInitList
private List addedThisInitializers = new ArrayList(); // List<NewFieldMunger>
- private List addedClassInitializers = new ArrayList(); // List<NewFieldMunger>
+ private List addedClassInitializers = new ArrayList(); // List<NewFieldMunger
+ // >
private Map mapToAnnotations = new HashMap();
return perKindShadowMungers[kind.getKey()] != null;
}
- // private void fastMatchShadowMungers(List shadowMungers, ArrayList mungers, Kind kind) {
+ // private void fastMatchShadowMungers(List shadowMungers, ArrayList
+ // mungers, Kind kind) {
// FastMatchInfo info = new FastMatchInfo(clazz.getType(), kind);
// for (Iterator i = shadowMungers.iterator(); i.hasNext();) {
// ShadowMunger munger = (ShadowMunger) i.next();
// FuzzyBoolean fb = munger.getPointcut().fastMatch(info);
- // WeaverMetrics.recordFastMatchResult(fb);// Could pass: munger.getPointcut().toString()
+ // WeaverMetrics.recordFastMatchResult(fb);// Could pass:
+ // munger.getPointcut().toString()
// if (fb.maybeTrue()) mungers.add(munger);
// }
// }
whatToBridgeToMethodGen.getAccessFlags(), whatToBridgeToMethodGen.getName(), whatToBridgeToMethodGen
.getSignature());
}
- LazyMethodGen bridgeMethod = makeBridgeMethod(clazz, theBridgeMethod); // The bridge method in this type will have the same
+ LazyMethodGen bridgeMethod = makeBridgeMethod(clazz, theBridgeMethod); // The
+ // bridge
+ // method
+ // in
+ // this
+ // type
+ // will
+ // have
+ // the
+ // same
// signature as the one in the supertype
- int newflags = bridgeMethod.getAccessFlags() | 0x00000040;/* BRIDGE = 0x00000040 */
+ int newflags = bridgeMethod.getAccessFlags() | 0x00000040;/*
+ * BRIDGE = 0x00000040
+ */
if ((newflags & 0x00000100) != 0)
- newflags = newflags - 0x100;/* NATIVE = 0x00000100 - need to clear it */
+ newflags = newflags - 0x100;/*
+ * NATIVE = 0x00000100 - need to clear it
+ */
bridgeMethod.setAccessFlags(newflags);
Type returnType = BcelWorld.makeBcelType(theBridgeMethod.getReturnType());
Type[] paramTypes = BcelWorld.makeBcelTypes(theBridgeMethod.getParameterTypes());
}
boolean shadowMungerMatched = match(mg);
if (shadowMungerMatched) {
- // For matching mungers, add their declaring aspects to the list that affected this type
+ // For matching mungers, add their declaring aspects to the list
+ // that affected this type
if (inReweavableMode || clazz.getType().isAspect())
aspectsAffectingType.addAll(findAspectsForMungers(mg));
isChanged = true;
}
}
- // FIXME AV - see #75442, for now this is not enough to fix the bug, comment that out until we really fix it
+ // FIXME AV - see #75442, for now this is not enough to fix the bug,
+ // comment that out until we really fix it
// // flush to save some memory
- // PerObjectInterfaceTypeMunger.unregisterFromAsAdvisedBy(clazz.getType());
+ // PerObjectInterfaceTypeMunger.unregisterFromAsAdvisedBy(clazz.getType()
+ // );
// finally, if we changed, we add in the introduced methods.
if (isChanged) {
clazz.getOrCreateWeaverStateInfo(inReweavableMode);
- weaveInAddedMethods(); // FIXME asc are these potentially affected by declare annotation?
+ weaveInAddedMethods(); // FIXME asc are these potentially affected
+ // by declare annotation?
}
if (inReweavableMode) {
return isChanged;
}
- // **************************** start of bridge method creation code *****************
+ // **************************** start of bridge method creation code
+ // *****************
// FIXME asc tidy this lot up !!
if (methodThatMightBeGettingOverridden.isPrivate())
return null; // we can't be overriding a private method
if (!methodThatMightBeGettingOverridden.getName().equals(mname))
- return null; // names dont match (this will also skip <init> and <clinit> too)
+ return null; // names dont match (this will also skip <init> and
+ // <clinit> too)
if (methodThatMightBeGettingOverridden.getParameterTypes().length != methodParamsArray.length)
return null; // check same number of parameters
if (!isVisibilityOverride(mmods, methodThatMightBeGettingOverridden, inSamePackage))
sameParams = false;
}
- // If the 'typeToCheck' represents a parameterized type then the method will be the parameterized form of the
- // generic method in the generic type. So if the method was 'void m(List<T> lt, T t)' and the parameterized type here
- // is I<String> then the method we are looking at will be 'void m(List<String> lt, String t)' which when erased
- // is 'void m(List lt,String t)' - so if the parameters *do* match then there is a generic method we are
+ // If the 'typeToCheck' represents a parameterized type then the method
+ // will be the parameterized form of the
+ // generic method in the generic type. So if the method was 'void
+ // m(List<T> lt, T t)' and the parameterized type here
+ // is I<String> then the method we are looking at will be 'void
+ // m(List<String> lt, String t)' which when erased
+ // is 'void m(List lt,String t)' - so if the parameters *do* match then
+ // there is a generic method we are
// overriding
if (sameParams) {
return methodThatMightBeGettingOverridden.getBackingGenericMember();
} else if (!methodThatMightBeGettingOverridden.getReturnType().getErasureSignature().equals(mrettype)) {
// addressing the wierd situation from bug 147801
- // just check whether these things are in the right relationship for covariance...
+ // just check whether these things are in the right relationship
+ // for covariance...
ResolvedType superReturn = typeToCheck.getWorld().resolve(
UnresolvedType.forSignature(methodThatMightBeGettingOverridden.getReturnType().getErasureSignature()));
ResolvedType subReturn = typeToCheck.getWorld().resolve(UnresolvedType.forSignature(mrettype));
String packageName = typeToCheck.getPackageName();
if (packageName == null)
packageName = "";
- boolean inSamePackage = packageName.equals(mpkg); // used when looking at visibility rules
+ boolean inSamePackage = packageName.equals(mpkg); // used when looking
+ // at visibility
+ // rules
ResolvedMember[] methods = typeToCheck.getDeclaredMethods();
for (int ii = 0; ii < methods.length; ii++) {
- ResolvedMember methodThatMightBeGettingOverridden = methods[ii]; // the method we are going to check
+ ResolvedMember methodThatMightBeGettingOverridden = methods[ii]; // the
+ // method
+ // we
+ // are
+ // going
+ // to
+ // check
ResolvedMember isOverriding = isOverriding(typeToCheck, methodThatMightBeGettingOverridden, mname, mrettype, mmods,
inSamePackage, methodParamsArray);
if (isOverriding != null)
List l = typeToCheck.getInterTypeMungers();
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
Object o = iterator.next();
- // FIXME asc if its not a BcelTypeMunger then its an EclipseTypeMunger ... do I need to worry about that?
+ // FIXME asc if its not a BcelTypeMunger then its an
+ // EclipseTypeMunger ... do I need to worry about that?
if (o instanceof BcelTypeMunger) {
BcelTypeMunger element = (BcelTypeMunger) o;
if (element.getMunger() instanceof NewMethodTypeMunger) {
public static boolean calculateAnyRequiredBridgeMethods(BcelWorld world, LazyClassGen clazz) {
world.ensureAdvancedConfigurationProcessed();
if (!world.isInJava5Mode())
- return false; // just double check... the caller should have already verified this
+ return false; // just double check... the caller should have already
+ // verified this
if (clazz.isInterface())
return false; // dont bother if we're an interface
boolean didSomething = false; // set if we build any bridge methods
// So what methods do we have right now in this class?
List /* LazyMethodGen */methods = clazz.getMethodGens();
- // Keep a set of all methods from this type - it'll help us to check if bridge methods
+ // Keep a set of all methods from this type - it'll help us to check if
+ // bridge methods
// have already been created, we don't want to do it twice!
Set methodsSet = new HashSet();
for (int i = 0; i < methods.size(); i++) {
LazyMethodGen aMethod = (LazyMethodGen) methods.get(i);
- methodsSet.add(aMethod.getName() + aMethod.getSignature()); // e.g. "foo(Ljava/lang/String;)V"
+ methodsSet.add(aMethod.getName() + aMethod.getSignature()); // e.g.
+ // "foo(Ljava/lang/String;)V"
}
// Now go through all the methods in this type
pkgName, bm);
if (overriddenMethod != null) {
String key = new StringBuffer().append(overriddenMethod.getName()).append(overriddenMethod.getSignatureErased())
- .toString(); // pr 237419
+ .toString(); // pr
+ // 237419
boolean alreadyHaveABridgeMethod = methodsSet.contains(key);
if (!alreadyHaveABridgeMethod) {
if (world.forDEBUG_bridgingCode)
.getPackageName(), bm);
if (overriddenMethod != null) {
String key = new StringBuffer().append(overriddenMethod.getName())
- .append(overriddenMethod.getSignatureErased()).toString(); // pr 237419
+ .append(overriddenMethod.getSignatureErased()).toString(); // pr
+ // 237419
boolean alreadyHaveABridgeMethod = methodsSet.contains(key);
if (!alreadyHaveABridgeMethod) {
createBridgeMethod(world, bridgeToCandidate, clazz, overriddenMethod);
return didSomething;
}
- // **************************** end of bridge method creation code *****************
+ // **************************** end of bridge method creation code
+ // *****************
/**
* Weave any declare @method/@ctor statements into the members of the supplied class
List itdMethodsCtors = getITDSubset(clazz, ResolvedTypeMunger.Method);
itdMethodsCtors.addAll(getITDSubset(clazz, ResolvedTypeMunger.Constructor));
if (!itdMethodsCtors.isEmpty()) {
- // Can't use the subset called 'decaMs' as it won't be right for ITDs...
+ // Can't use the subset called 'decaMs' as it won't be right for
+ // ITDs...
isChanged = weaveAtMethodOnITDSRepeatedly(allDecams, itdMethodsCtors, reportedProblems);
}
if (decaM.matches(mg.getMemberView(), world)) {
if (doesAlreadyHaveAnnotation(mg.getMemberView(), decaM, reportedProblems)) {
- // remove the declare @method since don't want an error when
+ // remove the declare @method since don't want
+ // an error when
// the annotation is already there
unusedDecams.remove(decaM);
continue; // skip this one...
if (annotationsToAdd == null)
annotationsToAdd = new ArrayList();
- AnnotationGen a = decaM.getAnnotationX().getBcelAnnotation();
+ AnnotationGen a = ((BcelAnnotation) decaM.getAnnotationX()).getBcelAnnotation();
AnnotationGen ag = new AnnotationGen(a, clazz.getConstantPool(), true);
annotationsToAdd.add(ag);
mg.addAnnotation(decaM.getAnnotationX());
reportMethodCtorWeavingMessage(clazz, mg.getMemberView(), decaM, mg.getDeclarationLineNumber());
isChanged = true;
modificationOccured = true;
- // remove the declare @method since have matched against it
+ // remove the declare @method since have matched
+ // against it
unusedDecams.remove(decaM);
} else {
if (!decaM.isStarredAnnotationPattern())
- worthRetrying.add(decaM); // an annotation is specified that might be put on by a subsequent decaf
+ worthRetrying.add(decaM); // an annotation is
+ // specified that
+ // might be put on
+ // by a subsequent
+ // decaf
}
}
DeclareAnnotation decaM = (DeclareAnnotation) iter.next();
if (decaM.matches(mg.getMemberView(), world)) {
if (doesAlreadyHaveAnnotation(mg.getMemberView(), decaM, reportedProblems)) {
- // remove the declare @method since don't want an error when
+ // remove the declare @method since don't
+ // want an error when
// the annotation is already there
unusedDecams.remove(decaM);
continue; // skip this one...
if (annotationsToAdd == null)
annotationsToAdd = new ArrayList();
- AnnotationGen a = decaM.getAnnotationX().getBcelAnnotation();
+ AnnotationGen a = ((BcelAnnotation) decaM.getAnnotationX()).getBcelAnnotation();
// CUSTARD superfluous?
- // AnnotationGen ag = new AnnotationGen(a,clazz.getConstantPool(),true);
+ // AnnotationGen ag = new
+ // AnnotationGen(a,clazz.getConstantPool
+ // (),true);
annotationsToAdd.add(a);
mg.addAnnotation(decaM.getAnnotationX());
isChanged = true;
modificationOccured = true;
forRemoval.add(decaM);
- // remove the declare @method since have matched against it
+ // remove the declare @method since have matched
+ // against it
unusedDecams.remove(decaM);
}
}
}
if (annotationsToAdd != null) {
Method oldMethod = mg.getMethod();
- MethodGen myGen = new MethodGen(oldMethod, clazz.getClassName(), clazz.getConstantPool(), false);// dont use
+ MethodGen myGen = new MethodGen(oldMethod, clazz.getClassName(), clazz.getConstantPool(), false);// dont
+ // use
// tags,
// they
// won't
} else {
if (!decaF.isStarredAnnotationPattern())
- worthRetrying.add(decaF); // an annotation is specified that might be put on by a subsequent decaf
+ worthRetrying.add(decaF); // an annotation is specified
+ // that might be put on by a
+ // subsequent decaf
}
}
modificationOccured = true;
} else {
if (!decaMC.isStarredAnnotationPattern())
- worthRetrying.add(decaMC); // an annotation is specified that might be put on by a subsequent decaf
+ worthRetrying.add(decaMC); // an annotation is specified
+ // that might be put on by a
+ // subsequent decaf
}
}
return isChanged;
}
- private boolean dontAddTwice(DeclareAnnotation decaF, AnnotationX[] dontAddMeTwice) {
+ private boolean dontAddTwice(DeclareAnnotation decaF, AnnotationAJ[] dontAddMeTwice) {
for (int i = 0; i < dontAddMeTwice.length; i++) {
- AnnotationX ann = dontAddMeTwice[i];
+ AnnotationAJ ann = dontAddMeTwice[i];
if (ann != null && decaF.getAnnotationX().getTypeName().equals(ann.getTypeName())) {
- // dontAddMeTwice[i] = null; // incase it really has been added twice!
+ // dontAddMeTwice[i] = null; // incase it really has been added
+ // twice!
return true;
}
}
// BUGWARNING not getting enough warnings out on declare @field ?
// There is a potential problem here with warnings not coming out - this
- // will occur if they are created on the second iteration round this loop.
+ // will occur if they are created on the second iteration round this
+ // loop.
// We currently deactivate error reporting for the second time round.
// A possible solution is to record what annotations were added by what
// decafs and check that to see if an error needs to be reported - this
List worthRetrying = new ArrayList();
boolean modificationOccured = false;
- AnnotationX[] dontAddMeTwice = aBcelField.getAnnotations();
+ AnnotationAJ[] dontAddMeTwice = aBcelField.getAnnotations();
// go through all the declare @field statements
for (Iterator iter = decaFs.iterator(); iter.hasNext();) {
if (!dontAddTwice(decaF, dontAddMeTwice)) {
if (doesAlreadyHaveAnnotation(aBcelField, decaF, reportedProblems)) {
- // remove the declare @field since don't want an error when
+ // remove the declare @field since don't
+ // want an error when
// the annotation is already there
unusedDecafs.remove(decaF);
continue;
}
- if (decaF.getAnnotationX().isRuntimeVisible()) { // isAnnotationWithRuntimeRetention(clazz.
+ if (decaF.getAnnotationX().isRuntimeVisible()) { // isAnnotationWithRuntimeRetention
+ // (
+ // clazz
+ // .
// getJavaClass(world))){
- // if(decaF.getAnnotationTypeX().isAnnotationWithRuntimeRetention(world)){
- // it should be runtime visible, so put it on the Field
- // Annotation a = decaF.getAnnotationX().getBcelAnnotation();
- // AnnotationGen ag = new AnnotationGen(a,clazz.getConstantPoolGen(),true);
- // FieldGen myGen = new FieldGen(fields[fieldCounter],clazz.getConstantPoolGen());
+ // if(decaF.getAnnotationTypeX().
+ // isAnnotationWithRuntimeRetention(world)){
+ // it should be runtime visible, so put it
+ // on the Field
+ // Annotation a =
+ // decaF.getAnnotationX().getBcelAnnotation
+ // ();
+ // AnnotationGen ag = new
+ // AnnotationGen(a,clazz
+ // .getConstantPoolGen(),true);
+ // FieldGen myGen = new
+ // FieldGen(fields[fieldCounter
+ // ],clazz.getConstantPoolGen());
// myGen.addAnnotation(ag);
// Field newField = myGen.getField();
aBcelField.addAnnotation(decaF.getAnnotationX());
- // clazz.replaceField(fields[fieldCounter],newField);
+ // clazz.replaceField(fields[fieldCounter],
+ // newField);
// fields[fieldCounter]=newField;
} else {
reportFieldAnnotationWeavingMessage(clazz, fields, fieldCounter, decaF);
isChanged = true;
modificationOccured = true;
- // remove the declare @field since have matched against it
+ // remove the declare @field since have matched
+ // against it
unusedDecafs.remove(decaF);
} else {
if (!decaF.isStarredAnnotationPattern())
- worthRetrying.add(decaF); // an annotation is specified that might be put on by a subsequent decaf
+ worthRetrying.add(decaF); // an annotation is
+ // specified that
+ // might be put on
+ // by a subsequent
+ // decaf
}
}
if (decaF.matches(aBcelField, world)) {
// below code is for recursive things
if (doesAlreadyHaveAnnotation(aBcelField, decaF, reportedProblems)) {
- // remove the declare @field since don't want an error when
+ // remove the declare @field since don't
+ // want an error when
// the annotation is already there
unusedDecafs.remove(decaF);
continue; // skip this one...
isChanged = true;
modificationOccured = true;
forRemoval.add(decaF);
- // remove the declare @field since have matched against it
+ // remove the declare @field since have matched
+ // against it
unusedDecafs.remove(decaF);
}
}
aspectsAffectingType.add(bAdvice.getConcreteAspect().getName());
}
} else {
- // It is a 'Checker' - we don't need to remember aspects that only contributed Checkers...
+ // It is a 'Checker' - we don't need to remember aspects
+ // that only contributed Checkers...
}
}
}
r.associateWithShadow(s);
if (s.getKind() == Shadow.PreInitialization) {
// XXX assert first instruction is an ALOAD_0.
- // a pre shadow goes from AFTER the first instruction (which we believe to
+ // a pre shadow goes from AFTER the first instruction (which we
+ // believe to
// be an ALOAD_0) to just before the call to super
r.associateWithTargets(Range.genStart(body, body.getStart().getNext()), Range.genEnd(body, call.getPrev()));
} else {
}
// public BcelVar genTempVar(UnresolvedType typeX) {
- // return new BcelVar(typeX.resolve(world), genTempVarIndex(typeX.getSize()));
+ // return new BcelVar(typeX.resolve(world),
+ // genTempVarIndex(typeX.getSize()));
// }
//
// private int genTempVarIndex(int size) {
public static void transformSynchronizedMethod(LazyMethodGen synchronizedMethod) {
if (trace.isTraceEnabled())
trace.enter("transformSynchronizedMethod", synchronizedMethod);
- // System.err.println("DEBUG: Transforming synchronized method: "+synchronizedMethod.getName());
+ // System.err.println("DEBUG: Transforming synchronized method: "+
+ // synchronizedMethod.getName());
final InstructionFactory fact = synchronizedMethod.getEnclosingClass().getFactory();
InstructionList body = synchronizedMethod.getBody();
InstructionList prepend = new InstructionList();
// MONITOREXIT logic:
- // We basically need to wrap the code from the method in a finally block that
- // will ensure monitorexit is called. Content on the finally block seems to
+ // We basically need to wrap the code from the method in a
+ // finally block that
+ // will ensure monitorexit is called. Content on the finally
+ // block seems to
// be always:
//
// E1: ALOAD_1
finallyBlock.append(InstructionConstants.ATHROW);
// finally -> E1
- // | GETSTATIC java.lang.System.out Ljava/io/PrintStream; (line 21)
+ // | GETSTATIC java.lang.System.out Ljava/io/PrintStream; (line
+ // 21)
// | LDC "hello"
- // | INVOKEVIRTUAL java.io.PrintStream.println (Ljava/lang/String;)V
+ // | INVOKEVIRTUAL java.io.PrintStream.println
+ // (Ljava/lang/String;)V
// | ALOAD_1 (line 20)
// | MONITOREXIT
// finally -> E1
// ATHROW
// L0: RETURN (line 23)
- // search for 'returns' and make them jump to the aload_<n>,monitorexit
+ // search for 'returns' and make them jump to the
+ // aload_<n>,monitorexit
InstructionHandle walker = body.getStart();
List rets = new ArrayList();
while (walker != null) {
walker = walker.getNext();
}
if (!rets.isEmpty()) {
- // need to ensure targeters for 'return' now instead target the load instruction
+ // need to ensure targeters for 'return' now instead target
+ // the load instruction
// (so we never jump over the monitorexit logic)
for (Iterator iter = rets.iterator(); iter.hasNext();) {
InstructionList monitorExitBlock = new InstructionList();
monitorExitBlock.append(InstructionFactory.createLoad(enclosingClassType, slotForLockObject));
monitorExitBlock.append(InstructionConstants.MONITOREXIT);
- // monitorExitBlock.append(Utility.copyInstruction(element.getInstruction()));
- // element.setInstruction(InstructionFactory.createLoad(classType,slotForThis));
+ // monitorExitBlock.append(Utility.copyInstruction(element
+ // .getInstruction()));
+ // element.setInstruction(InstructionFactory.createLoad(
+ // classType,slotForThis));
InstructionHandle monitorExitBlockStart = body.insert(element, monitorExitBlock);
- // now move the targeters from the RET to the start of the monitorexit block
+ // now move the targeters from the RET to the start of
+ // the monitorexit block
InstructionTargeter[] targeters = element.getTargetersArray();
if (targeters != null) {
for (int i = 0; i < targeters.length; i++) {
// ignore
} else if (targeter instanceof LineNumberTag) {
// ignore
- // } else if (targeter instanceof InstructionBranch && ((InstructionBranch)targeter).isGoto()) {
+ // } else if (targeter instanceof
+ // InstructionBranch &&
+ // ((InstructionBranch)targeter).isGoto()) {
// // move it...
- // targeter.updateTarget(element, monitorExitBlockStart);
+ // targeter.updateTarget(element,
+ // monitorExitBlockStart);
} else if (targeter instanceof InstructionBranch) {
// move it
targeter.updateTarget(element, monitorExitBlockStart);
InstructionHandle tryPosition = body.getStart();
InstructionHandle catchPosition = body.getEnd();
- body.insert(body.getStart(), prepend); // now we can put the monitorenter stuff on
+ body.insert(body.getStart(), prepend); // now we can put the
+ // monitorenter stuff on
synchronizedMethod.getBody().append(finallyBlock);
synchronizedMethod.addExceptionHandler(tryPosition, catchPosition, finallyStart, null/* ==finally */, false);
synchronizedMethod.addExceptionHandler(finallyStart, finallyStart.getNext(), finallyStart, null, false);
// 7: pop
// try
// 8: ldc #61; //String java.lang.String
- // 10: invokestatic #44; //Method java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
+ // 10: invokestatic #44; //Method
+ // java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
// 13: dup
// catch
// 14: putstatic #59; //Field class$1:Ljava/lang/Class;
// 20: new #46; //class java/lang/NoClassDefFoundError
// 23: dup_x1
// 24: swap
- // 25: invokevirtual #52; //Method java/lang/Throwable.getMessage:()Ljava/lang/String;
- // 28: invokespecial #54; //Method java/lang/NoClassDefFoundError."<init>":(Ljava/lang/String;)V
+ // 25: invokevirtual #52; //Method
+ // java/lang/Throwable.getMessage:()Ljava/lang/String;
+ // 28: invokespecial #54; //Method
+ // java/lang/NoClassDefFoundError."<init>":(Ljava/lang/String;)V
// 31: athrow
// 32: dup <-- partTwo (branch target)
// 33: astore_0
synchronizedMethod.getEnclosingClass().getConstantPool());
synchronizedMethod.getEnclosingClass().addField(f, null);
- // 10: invokestatic #44; //Method java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
+ // 10: invokestatic #44; //Method
+ // java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
// 13: dup
// 14: putstatic #59; //Field class$1:Ljava/lang/Class;
// 17: goto 32
// 20: new #46; //class java/lang/NoClassDefFoundError
// 23: dup_x1
// 24: swap
- // 25: invokevirtual #52; //Method java/lang/Throwable.getMessage:()Ljava/lang/String;
- // 28: invokespecial #54; //Method java/lang/NoClassDefFoundError."<init>":(Ljava/lang/String;)V
+ // 25: invokevirtual #52; //Method
+ // java/lang/Throwable.getMessage:()Ljava/lang/String;
+ // 28: invokespecial #54; //Method
+ // java/lang/NoClassDefFoundError."<init>":(Ljava/lang/String;)V
// 31: athrow
String name = synchronizedMethod.getEnclosingClass().getName();
prepend.append(catchBlockForLiteralLoadingFail);
prepend.append(parttwo);
// MONITORENTER
- // pseudocode: load up 'this' (var0), dup it, store it in a new local var (for use with monitorexit) and call
+ // pseudocode: load up 'this' (var0), dup it, store it in a new
+ // local var (for use with monitorexit) and call
// monitorenter:
// ALOAD_0, DUP, ASTORE_<n>, MONITORENTER
// prepend.append(InstructionFactory.createLoad(classType,0));
// prepend.append(InstructionFactory.createDup(1));
- // int slotForThis = synchronizedMethod.allocateLocal(classType);
- // prepend.append(InstructionFactory.createStore(classType, slotForThis));
+ // int slotForThis =
+ // synchronizedMethod.allocateLocal(classType);
+ // prepend.append(InstructionFactory.createStore(classType,
+ // slotForThis));
// prepend.append(InstructionFactory.MONITORENTER);
// MONITOREXIT
// here be dragons
- // We basically need to wrap the code from the method in a finally block that
- // will ensure monitorexit is called. Content on the finally block seems to
+ // We basically need to wrap the code from the method in a
+ // finally block that
+ // will ensure monitorexit is called. Content on the finally
+ // block seems to
// be always:
//
// E1: ALOAD_1
finallyBlock.append(InstructionConstants.ATHROW);
// finally -> E1
- // | GETSTATIC java.lang.System.out Ljava/io/PrintStream; (line 21)
+ // | GETSTATIC java.lang.System.out Ljava/io/PrintStream; (line
+ // 21)
// | LDC "hello"
- // | INVOKEVIRTUAL java.io.PrintStream.println (Ljava/lang/String;)V
+ // | INVOKEVIRTUAL java.io.PrintStream.println
+ // (Ljava/lang/String;)V
// | ALOAD_1 (line 20)
// | MONITOREXIT
// finally -> E1
// L0: RETURN (line 23)
// frameEnv.put(donorFramePos, thisSlot);
- // search for 'returns' and make them to the aload_<n>,monitorexit
+ // search for 'returns' and make them to the
+ // aload_<n>,monitorexit
InstructionHandle walker = body.getStart();
List rets = new ArrayList();
while (walker != null) { // !walker.equals(body.getEnd())) {
walker = walker.getNext();
}
if (rets.size() > 0) {
- // need to ensure targeters for 'return' now instead target the load instruction
+ // need to ensure targeters for 'return' now instead target
+ // the load instruction
// (so we never jump over the monitorexit logic)
for (Iterator iter = rets.iterator(); iter.hasNext();) {
InstructionHandle element = (InstructionHandle) iter.next();
- // System.err.println("Adding monitor exit block at "+element);
+ // System.err.println("Adding monitor exit block at "+
+ // element);
InstructionList monitorExitBlock = new InstructionList();
monitorExitBlock.append(InstructionFactory.createLoad(classType, slotForThis));
monitorExitBlock.append(InstructionConstants.MONITOREXIT);
- // monitorExitBlock.append(Utility.copyInstruction(element.getInstruction()));
- // element.setInstruction(InstructionFactory.createLoad(classType,slotForThis));
+ // monitorExitBlock.append(Utility.copyInstruction(element
+ // .getInstruction()));
+ // element.setInstruction(InstructionFactory.createLoad(
+ // classType,slotForThis));
InstructionHandle monitorExitBlockStart = body.insert(element, monitorExitBlock);
- // now move the targeters from the RET to the start of the monitorexit block
+ // now move the targeters from the RET to the start of
+ // the monitorexit block
InstructionTargeter[] targeters = element.getTargetersArray();
if (targeters != null) {
for (int i = 0; i < targeters.length; i++) {
// ignore
} else if (targeter instanceof LineNumberTag) {
// ignore
- // } else if (targeter instanceof GOTO || targeter instanceof GOTO_W) {
+ // } else if (targeter instanceof GOTO ||
+ // targeter instanceof GOTO_W) {
// // move it...
- // targeter.updateTarget(element, monitorExitBlockStart);
+ // targeter.updateTarget(element,
+ // monitorExitBlockStart);
} else if (targeter instanceof InstructionBranch) {
// move it
targeter.updateTarget(element, monitorExitBlockStart);
}
}
}
- // body = rewriteWithMonitorExitCalls(body,fact,true,slotForThis,classType);
+ // body =
+ // rewriteWithMonitorExitCalls(body,fact,true,slotForThis,
+ // classType);
// synchronizedMethod.setBody(body);
// now the magic, putting the finally block around the code
InstructionHandle tryPosition = body.getStart();
InstructionHandle catchPosition = body.getEnd();
- body.insert(body.getStart(), prepend); // now we can put the monitorenter stuff on
+ body.insert(body.getStart(), prepend); // now we can put the
+ // monitorenter stuff on
synchronizedMethod.getBody().append(finallyBlock);
synchronizedMethod.addExceptionHandler(tryPosition, catchPosition, finallyStart, null/* ==finally */, false);
// TRANSFORMING NON STATIC METHOD
Type classType = BcelWorld.makeBcelType(synchronizedMethod.getEnclosingClass().getType());
// MONITORENTER
- // pseudocode: load up 'this' (var0), dup it, store it in a new local var (for use with monitorexit) and call
+ // pseudocode: load up 'this' (var0), dup it, store it in a new
+ // local var (for use with monitorexit) and call
// monitorenter:
// ALOAD_0, DUP, ASTORE_<n>, MONITORENTER
prepend.append(InstructionFactory.createLoad(classType, 0));
// MONITOREXIT
- // We basically need to wrap the code from the method in a finally block that
- // will ensure monitorexit is called. Content on the finally block seems to
+ // We basically need to wrap the code from the method in a finally
+ // block that
+ // will ensure monitorexit is called. Content on the finally block
+ // seems to
// be always:
//
// E1: ALOAD_1
walker = walker.getNext();
}
if (!rets.isEmpty()) {
- // need to ensure targeters for 'return' now instead target the load instruction
+ // need to ensure targeters for 'return' now instead target the
+ // load instruction
// (so we never jump over the monitorexit logic)
for (Iterator iter = rets.iterator(); iter.hasNext();) {
InstructionHandle element = (InstructionHandle) iter.next();
- // System.err.println("Adding monitor exit block at "+element);
+ // System.err.println("Adding monitor exit block at "+element
+ // );
InstructionList monitorExitBlock = new InstructionList();
monitorExitBlock.append(InstructionFactory.createLoad(classType, slotForThis));
monitorExitBlock.append(InstructionConstants.MONITOREXIT);
- // monitorExitBlock.append(Utility.copyInstruction(element.getInstruction()));
- // element.setInstruction(InstructionFactory.createLoad(classType,slotForThis));
+ // monitorExitBlock.append(Utility.copyInstruction(element.
+ // getInstruction()));
+ // element.setInstruction(InstructionFactory.createLoad(
+ // classType,slotForThis));
InstructionHandle monitorExitBlockStart = body.insert(element, monitorExitBlock);
- // now move the targeters from the RET to the start of the monitorexit block
+ // now move the targeters from the RET to the start of the
+ // monitorexit block
InstructionTargeter[] targeters = element.getTargetersArray();
if (targeters != null) {
for (int i = 0; i < targeters.length; i++) {
// ignore
} else if (targeter instanceof LineNumberTag) {
// ignore
- // } else if (targeter instanceof GOTO || targeter instanceof GOTO_W) {
+ // } else if (targeter instanceof GOTO ||
+ // targeter instanceof GOTO_W) {
// // move it...
- // targeter.updateTarget(element, monitorExitBlockStart);
+ // targeter.updateTarget(element,
+ // monitorExitBlockStart);
} else if (targeter instanceof InstructionBranch) {
// move it
targeter.updateTarget(element, monitorExitBlockStart);
InstructionHandle tryPosition = body.getStart();
InstructionHandle catchPosition = body.getEnd();
- body.insert(body.getStart(), prepend); // now we can put the monitorenter stuff on
+ body.insert(body.getStart(), prepend); // now we can put the
+ // monitorenter stuff on
synchronizedMethod.getBody().append(finallyBlock);
synchronizedMethod.addExceptionHandler(tryPosition, catchPosition, finallyStart, null/* ==finally */, false);
synchronizedMethod.addExceptionHandler(finallyStart, finallyStart.getNext(), finallyStart, null, false);
// also the exception handling for the finally block jumps to itself
- // max locals will already have been modified in the allocateLocal() call
+ // max locals will already have been modified in the allocateLocal()
+ // call
// synchronized bit is removed on LazyMethodGen.pack()
}
- // gonna have to go through and change all aload_0s to load the var from a variable,
+ // gonna have to go through and change all aload_0s to load the var from
+ // a variable,
// going to add a new variable for the this var
if (trace.isTraceEnabled())
boolean isAcrossClass = donorCpg != recipientCpg;
- // first pass: copy the instructions directly, populate the srcToDest map,
+ // first pass: copy the instructions directly, populate the srcToDest
+ // map,
// fix frame instructions
for (InstructionHandle src = sourceList.getStart(); src != null; src = src.getNext()) {
Instruction fresh = Utility.copyInstruction(src.getInstruction());
// OPTIMIZE optimize this stuff?
if (fresh.isConstantPoolInstruction()) {
- // need to reset index to go to new constant pool. This is totally
+ // need to reset index to go to new constant pool. This is
+ // totally
// a computation leak... we're testing this LOTS of times. Sigh.
if (isAcrossClass) {
InstructionCP cpi = (InstructionCP) fresh;
freshRange.associateWithTargets(dest, (InstructionHandle) srcToDest.get(oldRange.getEnd()));
shadowMap.put(oldRange, freshRange);
// recipient.matchedShadows.add(freshShadow);
- // XXX should go through the NEW copied shadow and update
+ // XXX should go through the NEW copied shadow and
+ // update
// the thisVar, targetVar, and argsVar
- // ??? Might want to also go through at this time and add
+ // ??? Might want to also go through at this time and
+ // add
// "extra" vars to the shadow.
}
}
return ret;
}
- // static InstructionList rewriteWithMonitorExitCalls(InstructionList sourceList,InstructionFactory fact,boolean keepReturns,int
+ // static InstructionList rewriteWithMonitorExitCalls(InstructionList
+ // sourceList,InstructionFactory fact,boolean keepReturns,int
// monitorVarSlot,Type monitorVarType)
// {
// InstructionList footer = new InstructionList();
//
// Map srcToDest = new HashMap();
//
- // // first pass: copy the instructions directly, populate the srcToDest map,
+ // // first pass: copy the instructions directly, populate the srcToDest
+ // map,
// // fix frame instructions
- // for (InstructionHandle src = sourceList.getStart(); src != null; src = src.getNext()) {
+ // for (InstructionHandle src = sourceList.getStart(); src != null; src =
+ // src.getNext()) {
// Instruction fresh = Utility.copyInstruction(src.getInstruction());
// InstructionHandle dest;
// if (src.getInstruction() == Range.RANGEINSTRUCTION) {
// dest = newList.append(Range.RANGEINSTRUCTION);
// } else if (fresh.isReturnInstruction()) {
// if (keepReturns) {
- // newList.append(InstructionFactory.createLoad(monitorVarType,monitorVarSlot));
+ // newList.append(InstructionFactory.createLoad(monitorVarType,monitorVarSlot
+ // ));
// newList.append(InstructionConstants.MONITOREXIT);
// dest = newList.append(fresh);
// } else {
// dest =
- // newList.append(InstructionFactory.createBranchInstruction(Constants.GOTO, end));
+ // newList.append(InstructionFactory.createBranchInstruction(Constants.GOTO,
+ // end));
// }
// } else if (fresh instanceof InstructionBranch) {
// dest = newList.append((InstructionBranch) fresh);
//
// // second pass: retarget branch instructions, copy ranges and tags
// Map tagMap = new HashMap();
- // for (InstructionHandle dest = newList.getStart(), src = sourceList.getStart();
+ // for (InstructionHandle dest = newList.getStart(), src =
+ // sourceList.getStart();
// dest != null;
// dest = dest.getNext(), src = src.getNext()) {
// Instruction inst = dest.getInstruction();
// ExceptionRange er = (ExceptionRange) old;
// if (er.getStart() == src) {
// ExceptionRange freshEr =
- // new ExceptionRange(newList/*recipient.getBody()*/,er.getCatchType(),er.getPriority());
+ // new ExceptionRange(newList/*recipient.getBody()*/,er.getCatchType(),er.
+ // getPriority());
// freshEr.associateWithTargets(
// dest,
// (InstructionHandle)srcToDest.get(er.getEnd()),
}
// void addPerSingletonField(Member field) {
- // ObjectType aspectType = (ObjectType) BcelWorld.makeBcelType(field.getReturnType());
+ // ObjectType aspectType = (ObjectType)
+ // BcelWorld.makeBcelType(field.getReturnType());
// String aspectName = field.getReturnType().getName();
//
// LazyMethodGen clinit = clazz.getStaticInitializer();
//
// setup.append(fact.createNew(aspectType));
// setup.append(InstructionFactory.createDup(1));
- // setup.append(fact.createInvoke(aspectName, "<init>", Type.VOID, new Type[0], Constants.INVOKESPECIAL));
- // setup.append(fact.createFieldAccess(aspectName, field.getName(), aspectType, Constants.PUTSTATIC));
+ // setup.append(fact.createInvoke(aspectName, "<init>", Type.VOID, new
+ // Type[0], Constants.INVOKESPECIAL));
+ // setup.append(fact.createFieldAccess(aspectName, field.getName(),
+ // aspectType, Constants.PUTSTATIC));
// clinit.getBody().insert(setup);
// }
} else if (effective.isWeaveBody()) {
ResolvedMember rm = effective.getEffectiveSignature();
- // Annotations for things with effective signatures are never stored in the effective
- // signature itself - we have to hunt for them. Storing them in the effective signature
+ // Annotations for things with effective signatures are
+ // never stored in the effective
+ // signature itself - we have to hunt for them. Storing them
+ // in the effective signature
// would mean keeping two sets up to date (no way!!)
fixAnnotationsForResolvedMember(rm, mg.getMemberView());
match(mg, h, enclosingShadow, shadowAccumulator);
}
}
- // FIXME asc change from string match if we can, rather brittle. this check actually prevents field-exec jps
+ // FIXME asc change from string match if we can, rather brittle.
+ // this check actually prevents field-exec jps
if (canMatch(enclosingShadow.getKind())
&& !(mg.getName().charAt(0) == 'a' && mg.getName().startsWith("ajc$interFieldInit"))) {
if (match(enclosingShadow, shadowAccumulator)) {
}
// actually, you only need to inline the self constructors that are
- // in a particular group (partition the constructors into groups where members
+ // in a particular group (partition the constructors into groups where
+ // members
// call or are called only by those in the group). Then only inline
// constructors
// in groups where at least one initialization jp matched. Future work.
return;
if (!ih.getInstruction().isStoreInstruction() && ih.getInstruction().getOpcode() != Constants.NOP) {
- // If using cobertura, the catch block stats with INVOKESTATIC rather than ASTORE, in order that the
+ // If using cobertura, the catch block stats with
+ // INVOKESTATIC rather than ASTORE, in order that
+ // the
// ranges
- // for the methodcall and exceptionhandler shadows that occur at this same
- // line, we need to modify the instruction list to split them - adding a
- // NOP before the invokestatic that gets all the targeters
+ // for the methodcall and exceptionhandler shadows
+ // that occur at this same
+ // line, we need to modify the instruction list to
+ // split them - adding a
+ // NOP before the invokestatic that gets all the
+ // targeters
// that were aimed at the INVOKESTATIC
mg.getBody().insert(ih, InstructionConstants.NOP);
InstructionHandle newNOP = ih.getPrev();
- // what about a try..catch that starts at the start of the exception handler? need to only include
+ // what about a try..catch that starts at the start
+ // of the exception handler? need to only include
// certain targeters really.
er.updateTarget(ih, newNOP, mg.getBody());
for (int ii = 0; ii < targeters.length; ii++) {
FieldInstruction fi = (FieldInstruction) i;
if (fi.opcode == Constants.PUTFIELD || fi.opcode == Constants.PUTSTATIC) {
- // check for sets of constant fields. We first check the previous
- // instruction. If the previous instruction is a LD_WHATEVER (push
- // constant on the stack) then we must resolve the field to determine
- // if it's final. If it is final, then we don't generate a shadow.
+ // check for sets of constant fields. We first check the
+ // previous
+ // instruction. If the previous instruction is a LD_WHATEVER
+ // (push
+ // constant on the stack) then we must resolve the field to
+ // determine
+ // if it's final. If it is final, then we don't generate a
+ // shadow.
InstructionHandle prevHandle = ih.getPrev();
Instruction prevI = prevHandle.getInstruction();
if (Utility.isConstantPushInstruction(prevI)) {
if (resolvedField == null) {
// we can't find the field, so it's not a join point.
} else if (Modifier.isFinal(resolvedField.getModifiers())) {
- // it's final, so it's the set of a final constant, so it's
+ // it's final, so it's the set of a final constant, so
+ // it's
// not a join point according to 1.0.6 and 1.1.
} else {
if (canMatch(Shadow.FieldSet))
// we are private
matchInvokeInstruction(mg, ih, ii, enclosingShadow, shadowAccumulator);
} else {
- // we are a super call, and this is not a join point in AspectJ-1.{0,1}
+ // we are a super call, and this is not a join point in
+ // AspectJ-1.{0,1}
}
} else {
matchInvokeInstruction(mg, ih, ii, enclosingShadow, shadowAccumulator);
// } else if (i instanceof AALOAD ) {
// AALOAD arrayLoad = (AALOAD)i;
// Type arrayType = arrayLoad.getType(clazz.getConstantPoolGen());
- // BcelShadow arrayLoadShadow = BcelShadow.makeArrayLoadCall(world,mg,ih,enclosingShadow);
+ // BcelShadow arrayLoadShadow =
+ // BcelShadow.makeArrayLoadCall(world,mg,ih,enclosingShadow);
// match(arrayLoadShadow,shadowAccumulator);
// } else if (i instanceof AASTORE) {
// // ... magic required
} else {
ResolvedMember realthing = AjcMemberMaker.interMethodDispatcher(rm.resolve(world), memberHostType).resolve(
world);
- // ResolvedMember resolvedDooberry = world.resolve(realthing);
+ // ResolvedMember resolvedDooberry =
+ // world.resolve(realthing);
ResolvedMember theRealMember = findResolvedMemberNamed(memberHostType.resolve(world), realthing.getName());
// AMC temp guard for M4
if (theRealMember == null) {
} catch (UnsupportedOperationException ex) {
throw ex;
} catch (Throwable t) {
- // FIXME asc remove this catch after more testing has confirmed the above stuff is OK
+ // FIXME asc remove this catch after more testing has confirmed the
+ // above stuff is OK
throw new BCException("Unexpectedly went bang when searching for annotations on " + rm, t);
}
}
AjAttribute.EffectiveSignatureAttribute effectiveSig = declaredSig.getEffectiveSignature();
if (effectiveSig == null)
return;
- // System.err.println("call to inter-type member: " + effectiveSig);
+ // System.err.println("call to inter-type member: " +
+ // effectiveSig);
if (effectiveSig.isWeaveBody())
return;
}
}
- // static ... so all worlds will share the config for the first one created...
+ // static ... so all worlds will share the config for the first one
+ // created...
private static boolean checkedXsetForLowLevelContextCapturing = false;
private static boolean captureLowLevelContext = false;
private boolean match(BcelShadow shadow, List shadowAccumulator) {
// System.err.println("match: " + shadow);
- if (captureLowLevelContext) { // duplicate blocks - one with context capture, one without, seems faster than multiple
+ if (captureLowLevelContext) { // duplicate blocks - one with context
+ // capture, one without, seems faster
+ // than multiple
// 'ifs()'
ContextToken shadowMatchToken = CompilationAndWeavingContext.enteringPhase(
CompilationAndWeavingContext.MATCHING_SHADOW, shadow);
List shadows = mg.matchedShadows;
if (shadows == null)
return;
- // We depend on a partial order such that inner shadows are earlier on the list
+ // We depend on a partial order such that inner shadows are earlier on
+ // the list
// than outer shadows. That's fine. This order is preserved if:
// A preceeds B iff B.getStart() is LATER THAN A.getStart().
return world;
}
- // Called by the BcelWeaver to let us know all BcelClassWeavers need to collect reweavable info
+ // Called by the BcelWeaver to let us know all BcelClassWeavers need to
+ // collect reweavable info
public static void setReweavableMode(boolean mode) {
inReweavableMode = mode;
}
import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
import org.aspectj.apache.bcel.generic.FieldGen;
import org.aspectj.weaver.AjAttribute;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ResolvedMemberImpl;
import org.aspectj.weaver.ResolvedType;
private Field field;
private boolean isAjSynthetic;
private boolean isSynthetic = false;
- private AnnotationX[] annotations;
+ private AnnotationAJ[] annotations;
private World world;
private BcelObjectType bcelObjectType;
private UnresolvedType genericFieldType = null;
return ret;
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
ensureAnnotationTypesRetrieved();
return annotations;
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
ensureAnnotationTypesRetrieved();
for (int i = 0; i < annotations.length; i++) {
if (annotations[i].getTypeName().equals(ofType.getName()))
AnnotationGen annos[] = field.getAnnotations();
if (annos == null || annos.length == 0) {
annotationTypes = Collections.EMPTY_SET;
- annotations = AnnotationX.NONE;
+ annotations = AnnotationAJ.EMPTY_ARRAY;
} else {
annotationTypes = new HashSet();
- annotations = new AnnotationX[annos.length];
+ annotations = new AnnotationAJ[annos.length];
for (int i = 0; i < annos.length; i++) {
AnnotationGen annotation = annos[i];
annotationTypes.add(world.resolve(UnresolvedType.forSignature(annotation.getTypeSignature())));
- annotations[i] = new AnnotationX(annotation, world);
+ annotations[i] = new BcelAnnotation(annotation, world);
}
}
}
}
- public void addAnnotation(AnnotationX annotation) {
+ public void addAnnotation(AnnotationAJ annotation) {
ensureAnnotationTypesRetrieved();
// Add it to the set of annotations
int len = annotations.length;
- AnnotationX[] ret = new AnnotationX[len + 1];
+ AnnotationAJ[] ret = new AnnotationAJ[len + 1];
System.arraycopy(annotations, 0, ret, 0, len);
ret[len] = annotation;
annotations = ret;
AnnotationGen[] alreadyHas = fg.getAnnotations();
if (annotations != null) {
for (int i = 0; i < annotations.length; i++) {
- AnnotationX array_element = annotations[i];
+ AnnotationAJ array_element = annotations[i];
boolean alreadyHasIt = false;
for (int j = 0; j < alreadyHas.length; j++) {
AnnotationGen gen = alreadyHas[j];
alreadyHasIt = true;
}
if (!alreadyHasIt)
- fg.addAnnotation(new AnnotationGen(array_element.getBcelAnnotation(), cpg, true));
+ fg.addAnnotation(new AnnotationGen(((BcelAnnotation) array_element).getBcelAnnotation(), cpg, true));
}
}
field = fg.getField();
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.SourceLocation;
import org.aspectj.weaver.AjAttribute;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.MemberKind;
// these fields are not set for many BcelMethods...
private ShadowMunger associatedShadowMunger;
- private ResolvedPointcutDefinition preResolvedPointcut; // used when ajc has pre-resolved the pointcut of some @Advice
+ private ResolvedPointcutDefinition preResolvedPointcut; // used when ajc has
+ // pre-resolved the
+ // pointcut of some
+ // @Advice
private AjAttribute.EffectiveSignatureAttribute effectiveSignature;
private AjAttribute.MethodDeclarationLineNumberAttribute declarationLineNumber;
- private AnnotationX[] annotations = null;
- private AnnotationX[][] parameterAnnotations = null;
+ private AnnotationAJ[] annotations = null;
+ private AnnotationAJ[][] parameterAnnotations = null;
private BcelObjectType bcelObjectType;
private int bitflags;
private static final int UNPACKED_GENERIC_SIGNATURE = 0x0008;
private static final int IS_AJ_SYNTHETIC = 0x0040;
private static final int IS_SYNTHETIC = 0x0080;
- private static final int IS_SYNTHETIC_INVERSE = 0x7f7f; // all bits but IS_SYNTHETIC (and topmost bit)
+ private static final int IS_SYNTHETIC_INVERSE = 0x7f7f; // all bits but
+ // IS_SYNTHETIC (and
+ // topmost bit)
private static final int HAS_ANNOTATIONS = 0x0400;
private static final int HAVE_DETERMINED_ANNOTATIONS = 0x0800;
if (varTable == null) {
// do we have an annotation with the argNames value specified...
if (hasAnnotations()) {
- AnnotationX[] axs = getAnnotations();
+ AnnotationAJ[] axs = getAnnotations();
for (int i = 0; i < axs.length; i++) {
- AnnotationX annotationX = axs[i];
+ AnnotationAJ annotationX = axs[i];
String typename = annotationX.getTypeName();
if (typename.equals("org.aspectj.lang.annotation.Pointcut")
|| typename.equals("org.aspectj.lang.annotation.Before")
|| typename.equals("org.aspectj.lang.annotation.Around")
|| typename.startsWith("org.aspectj.lang.annotation.After")) {
- AnnotationGen a = annotationX.getBcelAnnotation();
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
if (a != null) {
List values = a.getValues();
for (Iterator iterator = values.iterator(); iterator.hasNext();) {
// System.out.println("found effective: " + this);
effectiveSignature = (AjAttribute.EffectiveSignatureAttribute) a;
} else if (a instanceof AjAttribute.PointcutDeclarationAttribute) {
- // this is an @AspectJ annotated advice method, with pointcut pre-resolved by ajc
+ // this is an @AspectJ annotated advice method, with pointcut
+ // pre-resolved by ajc
preResolvedPointcut = ((AjAttribute.PointcutDeclarationAttribute) a).reify();
} else {
throw new BCException("weird method attribute " + a);
}
}
- // for testing - if we have this attribute, return it - will return null if it doesnt know anything
+ // for testing - if we have this attribute, return it - will return null if
+ // it doesnt know anything
public AjAttribute[] getAttributes(String name) {
List results = new ArrayList();
List l = Utility.readAjAttributes(getDeclaringType().getClassName(), method.getAttributes(),
}
public boolean isAjSynthetic() {
- return (bitflags & IS_AJ_SYNTHETIC) != 0;// isAjSynthetic; // || getName().startsWith(NameMangler.PREFIX);
+ return (bitflags & IS_AJ_SYNTHETIC) != 0;// isAjSynthetic; // ||
+ // getName(
+ // ).startsWith(NameMangler
+ // .PREFIX);
}
// FIXME ??? needs an isSynthetic method
return false;
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
ensureAnnotationsRetrieved();
if ((bitflags & HAS_ANNOTATIONS) != 0) {
return annotations;
} else {
- return AnnotationX.NONE;
+ return AnnotationAJ.EMPTY_ARRAY;
}
}
return ret;
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
ensureAnnotationsRetrieved();
if ((bitflags & HAS_ANNOTATIONS) == 0)
return null;
return null;
}
- public void addAnnotation(AnnotationX annotation) {
+ public void addAnnotation(AnnotationAJ annotation) {
ensureAnnotationsRetrieved();
if ((bitflags & HAS_ANNOTATIONS) == 0) {
- annotations = new AnnotationX[1];
+ annotations = new AnnotationAJ[1];
annotations[0] = annotation;
} else {
// Add it to the set of annotations
int len = annotations.length;
- AnnotationX[] ret = new AnnotationX[len + 1];
+ AnnotationAJ[] ret = new AnnotationAJ[len + 1];
System.arraycopy(annotations, 0, ret, 0, len);
ret[len] = annotation;
annotations = ret;
if (annotationTypes == Collections.EMPTY_SET)
annotationTypes = new HashSet();
annotationTypes.add(UnresolvedType.forName(annotation.getTypeName()).resolve(bcelObjectType.getWorld()));
- // FIXME asc looks like we are managing two 'bunches' of annotations, one
+ // FIXME asc looks like we are managing two 'bunches' of annotations,
+ // one
// here and one in the real 'method' - should we reduce it to one layer?
// method.addAnnotation(annotation.getBcelAnnotation());
}
AnnotationGen annos[] = method.getAnnotations();
if (annos.length != 0) {
annotationTypes = new HashSet();
- annotations = new AnnotationX[annos.length];
+ annotations = new AnnotationAJ[annos.length];
for (int i = 0; i < annos.length; i++) {
AnnotationGen annotation = annos[i];
annotationTypes.add(bcelObjectType.getWorld().resolve(UnresolvedType.forSignature(annotation.getTypeSignature())));
- annotations[i] = new AnnotationX(annotation, bcelObjectType.getWorld());
+ annotations[i] = new BcelAnnotation(annotation, bcelObjectType.getWorld());
}
bitflags |= HAS_ANNOTATIONS;
} else {
parameterAnnotations = BcelMethod.NO_PARAMETER_ANNOTATIONXS;
} else {
AnnotationGen annos[][] = method.getParameterAnnotations();
- parameterAnnotations = new AnnotationX[annos.length][];
+ parameterAnnotations = new AnnotationAJ[annos.length][];
parameterAnnotationTypes = new ResolvedType[annos.length][];
for (int i = 0; i < annos.length; i++) {
- parameterAnnotations[i] = new AnnotationX[annos[i].length];
+ parameterAnnotations[i] = new AnnotationAJ[annos[i].length];
parameterAnnotationTypes[i] = new ResolvedType[annos[i].length];
for (int j = 0; j < annos[i].length; j++) {
- parameterAnnotations[i][j] = new AnnotationX(annos[i][j], bcelObjectType.getWorld());
+ parameterAnnotations[i][j] = new BcelAnnotation(annos[i][j], bcelObjectType.getWorld());
parameterAnnotationTypes[i][j] = bcelObjectType.getWorld().resolve(
UnresolvedType.forSignature(annos[i][j].getTypeSignature()));
}
}
}
- public AnnotationX[][] getParameterAnnotations() {
+ public AnnotationAJ[][] getParameterAnnotations() {
ensureParameterAnnotationsRetrieved();
return parameterAnnotations;
}
Signature.FormalTypeParameter[] parentFormals = bcelObjectType.getAllFormals();
Signature.FormalTypeParameter[] formals = new Signature.FormalTypeParameter[parentFormals.length
+ mSig.formalTypeParameters.length];
- // put method formal in front of type formals for overriding in lookup
+ // 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;
return (bitflags & IS_SYNTHETIC) != 0;// isSynthetic;
}
- // Pre Java5 synthetic is an attribute 'Synthetic', post Java5 it is a modifier (4096 or 0x1000)
+ // Pre Java5 synthetic is an attribute 'Synthetic', post Java5 it is a
+ // modifier (4096 or 0x1000)
private void workOutIfSynthetic() {
if ((bitflags & KNOW_IF_SYNTHETIC) != 0)
return;
import org.aspectj.weaver.AbstractReferenceTypeDelegate;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationTargetKind;
-import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ReferenceType;
private ResolvedMember[] fields = null;
private ResolvedMember[] methods = null;
private ResolvedType[] annotationTypes = null;
- private AnnotationX[] annotations = null;
+ private AnnotationAJ[] annotations = null;
private TypeVariable[] typeVars = null;
private String retentionPolicy;
private AnnotationTargetKind[] annotationTargetKinds;
private boolean isNested;
private boolean isObject = false; // set upon construction
private boolean isAnnotationStyleAspect = false;// set upon construction
- private boolean isCodeStyleAspect = false; // not redundant with field above!
+ private boolean isCodeStyleAspect = false; // not redundant with field
+ // above!
private int bitflag = 0x0000;
// discovery bits
private static final int DISCOVERED_ANNOTATION_RETENTION_POLICY = 0x0001;
private static final int UNPACKED_GENERIC_SIGNATURE = 0x0002;
- private static final int UNPACKED_AJATTRIBUTES = 0x0004; // see note(1) below
+ private static final int UNPACKED_AJATTRIBUTES = 0x0004; // see note(1)
+ // below
private static final int DISCOVERED_ANNOTATION_TARGET_KINDS = 0x0008;
private static final int DISCOVERED_DECLARED_SIGNATURE = 0x0010;
private static final int DISCOVERED_WHETHER_ANNOTATION_STYLE = 0x0020;
this.javaClass = javaClass;
initializeFromJavaclass();
- // ATAJ: set the delegate right now for @AJ pointcut, else it is done too late to lookup
+ // ATAJ: set the delegate right now for @AJ pointcut, else it is done
+ // too late to lookup
// @AJ pc refs annotation in class hierarchy
resolvedTypeX.setDelegate(this);
isObject = (javaClass.getSuperclassNameIndex() == 0);
ensureAspectJAttributesUnpacked();
// if (sourceContext instanceof SourceContextImpl) {
- // ((SourceContextImpl)sourceContext).setSourceFileName(javaClass.getSourceFileName());
+ // ((SourceContextImpl)sourceContext).setSourceFileName(javaClass.
+ // getSourceFileName());
// }
setSourcefilename(javaClass.getSourceFileName());
}
return TypeVariable.NONE;
if (typeVars == null) {
- Signature.ClassSignature classSig = getGenericClassTypeSignature();// cachedGenericClassTypeSignature;//javaClass.
+ Signature.ClassSignature classSig = getGenericClassTypeSignature();// cachedGenericClassTypeSignature
+ // ;
+ // /
+ // /
+ // javaClass
+ // .
// getGenericClassTypeSignature();
typeVars = new TypeVariable[classSig.formalTypeParameters.length];
for (int i = 0; i < typeVars.length; i++) {
setSourcefilename(sca.getSourceFileName());
}
} else if (a instanceof AjAttribute.WeaverVersionInfo) {
- wvInfo = (AjAttribute.WeaverVersionInfo) a; // Set the weaver version used to build this type
+ wvInfo = (AjAttribute.WeaverVersionInfo) a; // Set the weaver
+ // version used to
+ // build this type
} else {
throw new BCException("bad attribute " + a);
}
public void resetState() {
if (javaClass == null) {
// we might store the classname and allow reloading?
- // At this point we are relying on the world to not evict if it might want to reweave multiple times
+ // At this point we are relying on the world to not evict if it
+ // might want to reweave multiple times
throw new BCException("can't weave evicted type");
}
// this.perClause = null;
// this.weaverState = null;
// this.lazyClassGen = null;
- // this next line frees up memory, but need to understand incremental implications
+ // this next line frees up memory, but need to understand incremental
+ // implications
// before leaving it in.
// getResolvedTypeX().setSourceContext(null);
}
// System.err.println("creating lazy class gen for: " + this);
ret = new LazyClassGen(this);
// ret.print(System.err);
- // System.err.println("made LCG from : " + this.getJavaClass().getSuperclassName );
+ // System.err.println("made LCG from : " +
+ // this.getJavaClass().getSuperclassName );
if (isAspect()) {
lazyClassGen = ret;
}
interfaceSignatures = newInterfaceSignatures;
}
}
- // System.err.println("javaClass: " + Arrays.asList(javaClass.getInterfaceNames()) + " super " + superclassName);
+ // System.err.println("javaClass: " +
+ // Arrays.asList(javaClass.getInterfaceNames()) + " super " +
+ // superclassName);
// if (lazyClassGen != null) lazyClassGen.print();
}
return annotationTypes;
}
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
ensureAnnotationsUnpacked();
return annotations;
}
}
// evil mutator - adding state not stored in the java class
- public void addAnnotation(AnnotationX annotation) {
+ public void addAnnotation(AnnotationAJ annotation) {
bitflag |= DAMAGED;
int len = annotations.length;
- AnnotationX[] ret = new AnnotationX[len + 1];
+ AnnotationAJ[] ret = new AnnotationAJ[len + 1];
System.arraycopy(annotations, 0, ret, 0, len);
ret[len] = annotation;
annotations = ret;
if (isAnnotation()) {
ensureAnnotationsUnpacked();
for (int i = annotations.length - 1; i >= 0; i--) {
- AnnotationX ax = annotations[i];
+ AnnotationAJ ax = annotations[i];
if (ax.getTypeName().equals(UnresolvedType.AT_RETENTION.getName())) {
- List values = ax.getBcelAnnotation().getValues();
+ List values = ((BcelAnnotation) ax).getBcelAnnotation().getValues();
for (Iterator it = values.iterator(); it.hasNext();) {
ElementNameValuePairGen element = (ElementNameValuePairGen) it.next();
EnumElementValueGen v = (EnumElementValueGen) element.getValue();
if ((bitflag & DISCOVERED_ANNOTATION_TARGET_KINDS) != 0)
return annotationTargetKinds;
bitflag |= DISCOVERED_ANNOTATION_TARGET_KINDS;
- annotationTargetKinds = null; // null means we have no idea or the @Target annotation hasn't been used
+ annotationTargetKinds = null; // null means we have no idea or the
+ // @Target annotation hasn't been used
List targetKinds = new ArrayList();
if (isAnnotation()) {
AnnotationGen[] annotationsOnThisType = javaClass.getAnnotations();
AnnotationGen annos[] = javaClass.getAnnotations();
if (annos == null || annos.length == 0) {
annotationTypes = ResolvedType.NONE;
- annotations = AnnotationX.NONE;
+ annotations = AnnotationAJ.EMPTY_ARRAY;
} else {
World w = getResolvedTypeX().getWorld();
annotationTypes = new ResolvedType[annos.length];
- annotations = new AnnotationX[annos.length];
+ annotations = new AnnotationAJ[annos.length];
for (int i = 0; i < annos.length; i++) {
AnnotationGen annotation = annos[i];
annotationTypes[i] = w.resolve(UnresolvedType.forSignature(annotation.getTypeSignature()));
- annotations[i] = new AnnotationX(annotation, w);
+ annotations[i] = new BcelAnnotation(annotation, w);
}
}
}
if (cSig != null) {
formalsForResolution = cSig.formalTypeParameters;
if (isNested()) {
- // we have to find any type variables from the outer type before proceeding with resolution.
+ // we have to find any type variables from the outer type before
+ // proceeding with resolution.
Signature.FormalTypeParameter[] extraFormals = getFormalTypeParametersFromOuterClass();
if (extraFormals.length > 0) {
List allFormals = new ArrayList();
try {
// this.superClass =
// BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
- // superSig, formalsForResolution, getResolvedTypeX().getWorld());
+ // superSig, formalsForResolution,
+ // getResolvedTypeX().getWorld());
ResolvedType rt = BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(superSig, formalsForResolution,
getResolvedTypeX().getWorld());
+ " with generic signature " + getDeclaredGenericSignature() + " the following error was detected: "
+ e.getMessage());
}
- // this.interfaces = new ResolvedType[cSig.superInterfaceSignatures.length];
+ // this.interfaces = new
+ // ResolvedType[cSig.superInterfaceSignatures.length];
if (cSig.superInterfaceSignatures.length == 0) {
this.interfaceSignatures = NO_INTERFACE_SIGS;
} else {
for (int i = 0; i < cSig.superInterfaceSignatures.length; i++) {
try {
// this.interfaces[i] =
- // BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(
+ // BcelGenericSignatureToTypeXConverter.
+ // classTypeSignature2TypeX(
// cSig.superInterfaceSignatures[i],
// formalsForResolution,
// getResolvedTypeX().getWorld());
if (isGeneric()) {
// update resolved typex to point at generic type not raw type.
ReferenceType genericType = (ReferenceType) this.resolvedTypeX.getGenericType();
- // genericType.setSourceContext(this.resolvedTypeX.getSourceContext());
+ // genericType.setSourceContext(this.resolvedTypeX.getSourceContext()
+ // );
genericType.setStartPos(this.resolvedTypeX.getStartPos());
this.resolvedTypeX = genericType;
}
getDeclaredInterfaces();
getDeclaredFields();
getDeclaredMethods();
- // The lazyClassGen is preserved for aspects - it exists to enable around advice
- // inlining since the method will need 'injecting' into the affected class. If
- // XnoInline is on, we can chuck away the lazyClassGen since it won't be required
+ // The lazyClassGen is preserved for aspects - it exists to enable
+ // around advice
+ // inlining since the method will need 'injecting' into the affected
+ // class. If
+ // XnoInline is on, we can chuck away the lazyClassGen since it
+ // won't be required
// later.
if (getResolvedTypeX().getWorld().isXnoInline())
lazyClassGen = null;
for (int i = fields.length - 1; i >= 0; i--)
fields[i].evictWeavingState();
javaClass = null;
- // setSourceContext(SourceContextImpl.UNKNOWN_SOURCE_CONTEXT); // bit naughty
- // interfaces=null; // force reinit - may get us the right instances!
+ // setSourceContext(SourceContextImpl.UNKNOWN_SOURCE_CONTEXT); //
+ // bit naughty
+ // interfaces=null; // force reinit - may get us the right
+ // instances!
// superClass=null;
}
}
// --- methods for testing
- // for testing - if we have this attribute, return it - will return null if it doesnt know anything
+ // for testing - if we have this attribute, return it - will return null if
+ // it doesnt know anything
// public AjAttribute[] getAttributes(String name) {
// List results = new ArrayList();
- // List l = BcelAttributes.readAjAttributes(javaClass.getClassName(),javaClass.getAttributes(),
- // getResolvedTypeX().getSourceContext(),getResolvedTypeX().getWorld(),AjAttribute.WeaverVersionInfo.UNKNOWN);
+ // List l =
+ // BcelAttributes.readAjAttributes(javaClass.getClassName(),javaClass
+ // .getAttributes(),
+ // getResolvedTypeX().getSourceContext(),getResolvedTypeX().getWorld(),
+ // AjAttribute.WeaverVersionInfo.UNKNOWN);
// for (Iterator iter = l.iterator(); iter.hasNext();) {
// AjAttribute element = (AjAttribute) iter.next();
// if (element.getNameString().equals(name)) results.add(element);
// return null;
// }
//
- // // for testing - use with the method above - this returns *all* including those that are not Aj attributes
+ // // for testing - use with the method above - this returns *all* including
+ // those that are not Aj attributes
// public String[] getAttributeNames() {
// Attribute[] as = javaClass.getAttributes();
// String[] strs = new String[as.length];
* Alexandre Vasseur @AspectJ ITDs
* ******************************************************************/
-
package org.aspectj.weaver.bcel;
import java.lang.reflect.Modifier;
import java.util.Set;
import org.aspectj.apache.bcel.Constants;
-import org.aspectj.apache.bcel.generic.FieldGen;
-import org.aspectj.apache.bcel.generic.InstructionBranch;
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.classfile.Signature;
import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.generic.FieldGen;
+import org.aspectj.apache.bcel.generic.InstructionBranch;
import org.aspectj.apache.bcel.generic.InstructionConstants;
import org.aspectj.apache.bcel.generic.InstructionFactory;
import org.aspectj.apache.bcel.generic.InstructionHandle;
import org.aspectj.bridge.context.CompilationAndWeavingContext;
import org.aspectj.bridge.context.ContextToken;
import org.aspectj.weaver.AjcMemberMaker;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationOnTypeMunger;
-import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.AsmRelationshipProvider;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.patterns.DeclareAnnotation;
import org.aspectj.weaver.patterns.Pointcut;
-
//XXX addLazyMethodGen is probably bad everywhere
public class BcelTypeMunger extends ConcreteTypeMunger {
ContextToken tok = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.MUNGING_WITH, this);
boolean changed = false;
boolean worthReporting = true;
-
+
if (munger.getKind() == ResolvedTypeMunger.Field) {
- changed = mungeNewField(weaver, (NewFieldTypeMunger)munger);
+ changed = mungeNewField(weaver, (NewFieldTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.Method) {
- changed = mungeNewMethod(weaver, (NewMethodTypeMunger)munger);
- } else if (munger.getKind() == ResolvedTypeMunger.MethodDelegate) {
- changed = mungeMethodDelegate(weaver, (MethodDelegateTypeMunger)munger);
- } else if (munger.getKind() == ResolvedTypeMunger.FieldHost) {
- changed = mungeFieldHost(weaver, (MethodDelegateTypeMunger.FieldHostTypeMunger)munger);
+ changed = mungeNewMethod(weaver, (NewMethodTypeMunger) munger);
+ } else if (munger.getKind() == ResolvedTypeMunger.MethodDelegate) {
+ changed = mungeMethodDelegate(weaver, (MethodDelegateTypeMunger) munger);
+ } else if (munger.getKind() == ResolvedTypeMunger.FieldHost) {
+ changed = mungeFieldHost(weaver, (MethodDelegateTypeMunger.FieldHostTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.PerObjectInterface) {
- changed = mungePerObjectInterface(weaver, (PerObjectInterfaceTypeMunger)munger);
+ changed = mungePerObjectInterface(weaver, (PerObjectInterfaceTypeMunger) munger);
worthReporting = false;
} else if (munger.getKind() == ResolvedTypeMunger.PerTypeWithinInterface) {
// PTWIMPL Transform the target type (add the aspect instance field)
changed = mungePerTypeWithinTransformer(weaver);
worthReporting = false;
} else if (munger.getKind() == ResolvedTypeMunger.PrivilegedAccess) {
- changed = mungePrivilegedAccess(weaver, (PrivilegedAccessMunger)munger);
+ changed = mungePrivilegedAccess(weaver, (PrivilegedAccessMunger) munger);
worthReporting = false;
} else if (munger.getKind() == ResolvedTypeMunger.Constructor) {
- changed = mungeNewConstructor(weaver, (NewConstructorTypeMunger)munger);
+ changed = mungeNewConstructor(weaver, (NewConstructorTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.Parent) {
- changed = mungeNewParent(weaver, (NewParentTypeMunger)munger);
+ changed = mungeNewParent(weaver, (NewParentTypeMunger) munger);
} else if (munger.getKind() == ResolvedTypeMunger.AnnotationOnType) {
- changed = mungeNewAnnotationOnType(weaver,(AnnotationOnTypeMunger)munger);
- worthReporting=false;
- } else {
+ changed = mungeNewAnnotationOnType(weaver, (AnnotationOnTypeMunger) munger);
+ worthReporting = false;
+ } else {
throw new RuntimeException("unimplemented");
}
-
+
if (changed && munger.changesPublicSignature()) {
- WeaverStateInfo info =
- weaver.getLazyClassGen().getOrCreateWeaverStateInfo(BcelClassWeaver.getReweavableMode());
+ WeaverStateInfo info = weaver.getLazyClassGen().getOrCreateWeaverStateInfo(BcelClassWeaver.getReweavableMode());
info.addConcreteMunger(this);
}
if (changed && worthReporting) {
- AsmRelationshipProvider.getDefault().addRelationship(weaver.getLazyClassGen().getType(), munger,getAspectType());
+ AsmRelationshipProvider.getDefault().addRelationship(weaver.getLazyClassGen().getType(), munger, getAspectType());
}
-
+
// TAG: WeavingMessage
- if (changed && worthReporting && munger!=null && !weaver.getWorld().getMessageHandler().isIgnoring(IMessage.WEAVEINFO)) {
+ if (changed && worthReporting && munger != null && !weaver.getWorld().getMessageHandler().isIgnoring(IMessage.WEAVEINFO)) {
String tName = weaver.getLazyClassGen().getType().getSourceLocation().getSourceFile().getName();
- if (tName.indexOf("no debug info available")!=-1) tName = "no debug info available";
- else tName = getShortname(weaver.getLazyClassGen().getType().getSourceLocation().getSourceFile().getPath());
+ if (tName.indexOf("no debug info available") != -1)
+ tName = "no debug info available";
+ else
+ tName = getShortname(weaver.getLazyClassGen().getType().getSourceLocation().getSourceFile().getPath());
String fName = getShortname(getAspectType().getSourceLocation().getSourceFile().getPath());
- if (munger.getKind().equals(ResolvedTypeMunger.Parent)) {
- // This message could come out of AjLookupEnvironment.addParent if doing parents
- // munging at compile time only...
- NewParentTypeMunger parentTM = (NewParentTypeMunger)munger;
- if (parentTM.getNewParent().isInterface()) {
- weaver.getWorld().getMessageHandler().handleMessage(WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_DECLAREPARENTSIMPLEMENTS,
- new String[]{weaver.getLazyClassGen().getType().getName(),
- tName,parentTM.getNewParent().getName(),fName},
- weaver.getLazyClassGen().getClassName(), getAspectType().getName()));
- } else {
- weaver.getWorld().getMessageHandler().handleMessage(
- WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_DECLAREPARENTSEXTENDS,
- new String[]{weaver.getLazyClassGen().getType().getName(),
- tName,parentTM.getNewParent().getName(),fName
- }));
-// TAG: WeavingMessage DECLARE PARENTS: EXTENDS
-// reportDeclareParentsMessage(WeaveMessage.WEAVEMESSAGE_DECLAREPARENTSEXTENDS,sourceType,parent);
-
- }
- } else if (munger.getKind().equals(ResolvedTypeMunger.FieldHost)) {
- //hidden
- } else {
- ResolvedMember declaredSig = munger.getSignature();
-// if (declaredSig==null) declaredSig= munger.getSignature();
- weaver.getWorld().getMessageHandler().handleMessage(WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ITD,
- new String[]{weaver.getLazyClassGen().getType().getName(),
- tName,munger.getKind().toString().toLowerCase(),
- getAspectType().getName(),
- fName+":'"+declaredSig+"'"},
- weaver.getLazyClassGen().getClassName(), getAspectType().getName()));
- }
+ if (munger.getKind().equals(ResolvedTypeMunger.Parent)) {
+ // This message could come out of AjLookupEnvironment.addParent
+ // if doing parents
+ // munging at compile time only...
+ NewParentTypeMunger parentTM = (NewParentTypeMunger) munger;
+ if (parentTM.getNewParent().isInterface()) {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_DECLAREPARENTSIMPLEMENTS,
+ new String[] { weaver.getLazyClassGen().getType().getName(), tName,
+ parentTM.getNewParent().getName(), fName }, weaver.getLazyClassGen().getClassName(),
+ getAspectType().getName()));
+ } else {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ WeaveMessage
+ .constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_DECLAREPARENTSEXTENDS, new String[] {
+ weaver.getLazyClassGen().getType().getName(), tName, parentTM.getNewParent().getName(),
+ fName }));
+ // TAG: WeavingMessage DECLARE PARENTS: EXTENDS
+ // reportDeclareParentsMessage(WeaveMessage.
+ // WEAVEMESSAGE_DECLAREPARENTSEXTENDS,sourceType,parent);
+
+ }
+ } else if (munger.getKind().equals(ResolvedTypeMunger.FieldHost)) {
+ // hidden
+ } else {
+ ResolvedMember declaredSig = munger.getSignature();
+ // if (declaredSig==null) declaredSig= munger.getSignature();
+ weaver.getWorld().getMessageHandler().handleMessage(
+ WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ITD, new String[] {
+ weaver.getLazyClassGen().getType().getName(), tName, munger.getKind().toString().toLowerCase(),
+ getAspectType().getName(), fName + ":'" + declaredSig + "'" }, weaver.getLazyClassGen()
+ .getClassName(), getAspectType().getName()));
+ }
}
-
+
CompilationAndWeavingContext.leavingPhase(tok);
return changed;
}
- private String getShortname(String path) {
+ private String getShortname(String path) {
int takefrom = path.lastIndexOf('/');
if (takefrom == -1) {
takefrom = path.lastIndexOf('\\');
}
- return path.substring(takefrom+1);
+ return path.substring(takefrom + 1);
}
-
- private boolean mungeNewAnnotationOnType(BcelClassWeaver weaver,AnnotationOnTypeMunger munger) {
- // FIXME asc this has already been done up front, need to do it here too?
- weaver.getLazyClassGen().addAnnotation(munger.getNewAnnotation().getBcelAnnotation());
+
+ private boolean mungeNewAnnotationOnType(BcelClassWeaver weaver, AnnotationOnTypeMunger munger) {
+ // FIXME asc this has already been done up front, need to do it here
+ // too?
+ weaver.getLazyClassGen().addAnnotation(((BcelAnnotation) munger.getNewAnnotation()).getBcelAnnotation());
return true;
}
- /**
- * For a long time, AspectJ did not allow binary weaving of declare parents. This restriction is now lifted
- * but could do with more testing!
+ /**
+ * For a long time, AspectJ did not allow binary weaving of declare parents. This restriction is now lifted but could do with
+ * more testing!
*/
private boolean mungeNewParent(BcelClassWeaver weaver, NewParentTypeMunger munger) {
- LazyClassGen newParentTarget = weaver.getLazyClassGen();
- ResolvedType newParent = munger.getNewParent();
-
- boolean cont = true; // Set to false when we error, so we don't actually *do* the munge
- cont = enforceDecpRule1_abstractMethodsImplemented(weaver, munger.getSourceLocation(),newParentTarget, newParent);
- cont = enforceDecpRule2_cantExtendFinalClass(weaver,munger.getSourceLocation(),newParentTarget,newParent) && cont;
-
- List methods = newParent.getMethodsWithoutIterator(false,true);
- for (Iterator iter = methods.iterator(); iter.hasNext();) {
- ResolvedMember superMethod = (ResolvedMember) iter.next();
- if (!superMethod.getName().equals("<init>")) {
- LazyMethodGen subMethod = findMatchingMethod(newParentTarget, superMethod);
- if (subMethod!=null && !subMethod.isBridgeMethod()) { // FIXME asc is this safe for all bridge methods?
- if (!(subMethod.isSynthetic() && superMethod.isSynthetic())) {
- if (!(subMethod.isStatic() && subMethod.getName().startsWith("access$"))) { // ignore generated accessors
- cont = enforceDecpRule3_visibilityChanges(weaver, newParent, superMethod, subMethod) && cont;
- cont = enforceDecpRule4_compatibleReturnTypes(weaver, superMethod, subMethod) && cont;
- cont = enforceDecpRule5_cantChangeFromStaticToNonstatic(weaver,munger.getSourceLocation(),superMethod,subMethod) && cont;
- }
- }
- }
- }
- }
- if (!cont) return false; // A rule was violated and an error message already reported
-
- if (newParent.isClass()) { // Changing the supertype
- if (!attemptToModifySuperCalls(weaver,newParentTarget,newParent)) return false;
- newParentTarget.setSuperClass(newParent);
+ LazyClassGen newParentTarget = weaver.getLazyClassGen();
+ ResolvedType newParent = munger.getNewParent();
+
+ boolean cont = true; // Set to false when we error, so we don't actually
+ // *do* the munge
+ cont = enforceDecpRule1_abstractMethodsImplemented(weaver, munger.getSourceLocation(), newParentTarget, newParent);
+ cont = enforceDecpRule2_cantExtendFinalClass(weaver, munger.getSourceLocation(), newParentTarget, newParent) && cont;
+
+ List methods = newParent.getMethodsWithoutIterator(false, true);
+ for (Iterator iter = methods.iterator(); iter.hasNext();) {
+ ResolvedMember superMethod = (ResolvedMember) iter.next();
+ if (!superMethod.getName().equals("<init>")) {
+ LazyMethodGen subMethod = findMatchingMethod(newParentTarget, superMethod);
+ if (subMethod != null && !subMethod.isBridgeMethod()) { // FIXME
+ // asc
+ // is
+ // this
+ // safe
+ // for
+ // all
+ // bridge
+ // methods
+ // ?
+ if (!(subMethod.isSynthetic() && superMethod.isSynthetic())) {
+ if (!(subMethod.isStatic() && subMethod.getName().startsWith("access$"))) { // ignore generated
+ // accessors
+ cont = enforceDecpRule3_visibilityChanges(weaver, newParent, superMethod, subMethod) && cont;
+ cont = enforceDecpRule4_compatibleReturnTypes(weaver, superMethod, subMethod) && cont;
+ cont = enforceDecpRule5_cantChangeFromStaticToNonstatic(weaver, munger.getSourceLocation(),
+ superMethod, subMethod)
+ && cont;
+ }
+ }
+ }
+ }
+ }
+ if (!cont)
+ return false; // A rule was violated and an error message already
+ // reported
+
+ if (newParent.isClass()) { // Changing the supertype
+ if (!attemptToModifySuperCalls(weaver, newParentTarget, newParent))
+ return false;
+ newParentTarget.setSuperClass(newParent);
} else { // Adding a new interface
- newParentTarget.addInterface(newParent,getSourceLocation());
+ newParentTarget.addInterface(newParent, getSourceLocation());
}
return true;
}
+ /**
+ * Rule 1: For the declare parents to be allowed, the target type must override and implement inherited abstract methods (if the
+ * type is not declared abstract)
+ */
+ private boolean enforceDecpRule1_abstractMethodsImplemented(BcelClassWeaver weaver, ISourceLocation mungerLoc,
+ LazyClassGen newParentTarget, ResolvedType newParent) {
+ boolean ruleCheckingSucceeded = true;
+ if (!(newParentTarget.isAbstract() || newParentTarget.isInterface())) { // Ignore
+ // abstract
+ // classes
+ // or
+ // interfaces
+ List methods = newParent.getMethodsWithoutIterator(false, true);
+ for (Iterator i = methods.iterator(); i.hasNext();) {
+ ResolvedMember o = (ResolvedMember) i.next();
+ if (o.isAbstract() && !o.getName().startsWith("ajc$interField")) { // Ignore
+ // abstract
+ // methods
+ // of
+ // ajc$interField
+ // prefixed
+ // methods
+ ResolvedMember discoveredImpl = null;
+ List newParentTargetMethods = newParentTarget.getType().getMethodsWithoutIterator(false, true);
+ for (Iterator ii = newParentTargetMethods.iterator(); ii.hasNext() && discoveredImpl == null;) {
+ ResolvedMember gen2 = (ResolvedMember) ii.next();
+ if (gen2.getName().equals(o.getName()) && gen2.getParameterSignature().equals(o.getParameterSignature())
+ && !gen2.isAbstract()) {
+ discoveredImpl = gen2; // Found a valid
+ // implementation !
+ }
+ }
+ if (discoveredImpl == null) {
+ // didnt find a valid implementation, lets check the
+ // ITDs on this type to see if they satisfy it
+ boolean satisfiedByITD = false;
+ for (Iterator ii = newParentTarget.getType().getInterTypeMungersIncludingSupers().iterator(); ii.hasNext();) {
+ ConcreteTypeMunger m = (ConcreteTypeMunger) ii.next();
+ if (m.getMunger() != null && m.getMunger().getKind() == ResolvedTypeMunger.Method) {
+ ResolvedMember sig = m.getSignature();
+ if (!Modifier.isAbstract(sig.getModifiers())) {
+
+ // If the ITD shares a type variable with
+ // some target type, we need to tailor it
+ // for that
+ // type
+ if (m.isTargetTypeParameterized()) {
+ ResolvedType genericOnType = getWorld().resolve(sig.getDeclaringType()).getGenericType();
+ m = m.parameterizedFor(newParent.discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
+ sig = m.getSignature(); // possible sig
+ // change when
+ // type
+ // parameters
+ // filled in
+ }
+ if (ResolvedType.matches(AjcMemberMaker.interMethod(sig, m.getAspectType(), sig
+ .getDeclaringType().resolve(weaver.getWorld()).isInterface()), o)) {
+ satisfiedByITD = true;
+ }
+ }
+ } else if (m.getMunger() != null && m.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate) {
+ satisfiedByITD = true;// AV - that should be
+ // enough, no need to
+ // check more
+ }
+ }
+ if (!satisfiedByITD) {
+ error(weaver, "The type " + newParentTarget.getName()
+ + " must implement the inherited abstract method " + o.getDeclaringType() + "." + o.getName()
+ + o.getParameterSignature(), newParentTarget.getType().getSourceLocation(),
+ new ISourceLocation[] { o.getSourceLocation(), mungerLoc });
+ ruleCheckingSucceeded = false;
+ }
+ }
+ }
+ }
+ }
+ return ruleCheckingSucceeded;
+ }
- /**
- * Rule 1: For the declare parents to be allowed, the target type must override and implement
- * inherited abstract methods (if the type is not declared abstract)
- */
- private boolean enforceDecpRule1_abstractMethodsImplemented(BcelClassWeaver weaver, ISourceLocation mungerLoc,LazyClassGen newParentTarget, ResolvedType newParent) {
- boolean ruleCheckingSucceeded = true;
- if (!(newParentTarget.isAbstract() || newParentTarget.isInterface())) { // Ignore abstract classes or interfaces
- List methods = newParent.getMethodsWithoutIterator(false,true);
- for (Iterator i = methods.iterator(); i.hasNext();) {
- ResolvedMember o = (ResolvedMember)i.next();
- if (o.isAbstract() && !o.getName().startsWith("ajc$interField")) { // Ignore abstract methods of ajc$interField prefixed methods
- ResolvedMember discoveredImpl = null;
- List newParentTargetMethods = newParentTarget.getType().getMethodsWithoutIterator(false,true);
- for (Iterator ii = newParentTargetMethods.iterator(); ii.hasNext() && discoveredImpl==null;) {
- ResolvedMember gen2 = (ResolvedMember) ii.next();
- if (gen2.getName().equals(o.getName()) &&
- gen2.getParameterSignature().equals(o.getParameterSignature()) && !gen2.isAbstract()) {
- discoveredImpl = gen2; // Found a valid implementation !
- }
- }
- if (discoveredImpl == null) {
- // didnt find a valid implementation, lets check the ITDs on this type to see if they satisfy it
- boolean satisfiedByITD = false;
- for (Iterator ii = newParentTarget.getType().getInterTypeMungersIncludingSupers().iterator(); ii.hasNext(); ) {
- ConcreteTypeMunger m = (ConcreteTypeMunger)ii.next();
- if (m.getMunger()!=null && m.getMunger().getKind() == ResolvedTypeMunger.Method) {
- ResolvedMember sig = m.getSignature();
- if (!Modifier.isAbstract(sig.getModifiers())) {
-
- // If the ITD shares a type variable with some target type, we need to tailor it for that
- // type
- if (m.isTargetTypeParameterized()) {
- ResolvedType genericOnType = getWorld().resolve(sig.getDeclaringType()).getGenericType();
- m = m.parameterizedFor(newParent.discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
- sig = m.getSignature(); // possible sig change when type parameters filled in
- }
- if (ResolvedType
- .matches(
- AjcMemberMaker.interMethod(
- sig,m.getAspectType(),sig.getDeclaringType().resolve(weaver.getWorld()).isInterface()),o)) {
- satisfiedByITD = true;
- }
- }
- } else if (m.getMunger()!=null && m.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate) {
- satisfiedByITD = true;//AV - that should be enough, no need to check more
- }
- }
- if (!satisfiedByITD) {
- error(weaver,
- "The type " + newParentTarget.getName() + " must implement the inherited abstract method "+o.getDeclaringType()+"."+o.getName()+o.getParameterSignature(),
- newParentTarget.getType().getSourceLocation(),new ISourceLocation[]{o.getSourceLocation(),mungerLoc});
- ruleCheckingSucceeded=false;
- }
- }
- }
- }
- }
- return ruleCheckingSucceeded;
- }
-
- /**
- * Rule 2. Can't extend final types
- */
- private boolean enforceDecpRule2_cantExtendFinalClass(BcelClassWeaver weaver, ISourceLocation mungerLoc,
- LazyClassGen newParentTarget, ResolvedType newParent) {
- if (newParent.isFinal()) {
- error(weaver,"Cannot make type "+newParentTarget.getName()+" extend final class "+newParent.getName(),
- newParentTarget.getType().getSourceLocation(),
- new ISourceLocation[]{mungerLoc});
- return false;
- }
+ /**
+ * Rule 2. Can't extend final types
+ */
+ private boolean enforceDecpRule2_cantExtendFinalClass(BcelClassWeaver weaver, ISourceLocation mungerLoc,
+ LazyClassGen newParentTarget, ResolvedType newParent) {
+ if (newParent.isFinal()) {
+ error(weaver, "Cannot make type " + newParentTarget.getName() + " extend final class " + newParent.getName(),
+ newParentTarget.getType().getSourceLocation(), new ISourceLocation[] { mungerLoc });
+ return false;
+ }
return true;
}
+ /**
+ * Rule 3. Can't narrow visibility of methods when overriding
+ */
+ private boolean enforceDecpRule3_visibilityChanges(BcelClassWeaver weaver, ResolvedType newParent, ResolvedMember superMethod,
+ LazyMethodGen subMethod) {
+ boolean cont = true;
+ if (superMethod.isPublic()) {
+ if (subMethod.isProtected() || subMethod.isDefault() || subMethod.isPrivate()) {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error("Cannot reduce the visibility of the inherited method '" + superMethod + "' from "
+ + newParent.getName(), superMethod.getSourceLocation()));
+ cont = false;
+ }
+ } else if (superMethod.isProtected()) {
+ if (subMethod.isDefault() || subMethod.isPrivate()) {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error("Cannot reduce the visibility of the inherited method '" + superMethod + "' from "
+ + newParent.getName(), superMethod.getSourceLocation()));
+ cont = false;
+ }
+ } else if (superMethod.isDefault()) {
+ if (subMethod.isPrivate()) {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error("Cannot reduce the visibility of the inherited method '" + superMethod + "' from "
+ + newParent.getName(), superMethod.getSourceLocation()));
+ cont = false;
+ }
+ }
+ return cont;
+ }
/**
- * Rule 3. Can't narrow visibility of methods when overriding
+ * Rule 4. Can't have incompatible return types
*/
- private boolean enforceDecpRule3_visibilityChanges(BcelClassWeaver weaver, ResolvedType newParent, ResolvedMember superMethod, LazyMethodGen subMethod) {
- boolean cont = true;
- if (superMethod.isPublic()) {
- if (subMethod.isProtected() || subMethod.isDefault() || subMethod.isPrivate()) {
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- "Cannot reduce the visibility of the inherited method '"+superMethod+"' from "+newParent.getName(),
- superMethod.getSourceLocation()));
- cont=false;
- }
- } else if (superMethod.isProtected()) {
- if (subMethod.isDefault() || subMethod.isPrivate()) {
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- "Cannot reduce the visibility of the inherited method '"+superMethod+"' from "+newParent.getName(),
- superMethod.getSourceLocation()));
- cont=false;
- }
- } else if (superMethod.isDefault()) {
- if (subMethod.isPrivate()) {
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- "Cannot reduce the visibility of the inherited method '"+superMethod+"' from "+newParent.getName(),
- superMethod.getSourceLocation()));
- cont=false;
- }
- }
+ private boolean enforceDecpRule4_compatibleReturnTypes(BcelClassWeaver weaver, ResolvedMember superMethod,
+ LazyMethodGen subMethod) {
+ boolean cont = true;
+ String superReturnTypeSig = superMethod.getGenericReturnType().getSignature(); // eg. Pjava/util/Collection<LFoo;>
+ String subReturnTypeSig = subMethod.getGenericReturnTypeSignature();
+ superReturnTypeSig = superReturnTypeSig.replace('.', '/');
+ subReturnTypeSig = subReturnTypeSig.replace('.', '/');
+ if (!superReturnTypeSig.equals(subReturnTypeSig)) {
+ // Check for covariance
+ ResolvedType subType = weaver.getWorld().resolve(subMethod.getReturnType());
+ ResolvedType superType = weaver.getWorld().resolve(superMethod.getReturnType());
+ if (!superType.isAssignableFrom(subType)) {
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error("The return type is incompatible with " + superMethod.getDeclaringType() + "."
+ + superMethod.getName() + superMethod.getParameterSignature(), subMethod.getSourceLocation()));
+ // this just might be a better error message...
+ // "The return type '"+subReturnTypeSig+
+ // "' is incompatible with the overridden method "
+ // +superMethod.getDeclaringType()+"."+
+ // superMethod.getName()+superMethod.getParameterSignature()+
+ // " which returns '"+superReturnTypeSig+"'",
+ cont = false;
+ }
+ }
return cont;
}
-
- /**
- * Rule 4. Can't have incompatible return types
- */
- private boolean enforceDecpRule4_compatibleReturnTypes(BcelClassWeaver weaver, ResolvedMember superMethod, LazyMethodGen subMethod) {
- boolean cont = true;
- String superReturnTypeSig = superMethod.getGenericReturnType().getSignature(); // eg. Pjava/util/Collection<LFoo;>
- String subReturnTypeSig = subMethod.getGenericReturnTypeSignature();
- superReturnTypeSig = superReturnTypeSig.replace('.', '/');
- subReturnTypeSig = subReturnTypeSig.replace('.', '/');
- if (!superReturnTypeSig.equals(subReturnTypeSig)) {
- // Check for covariance
- ResolvedType subType = weaver.getWorld().resolve(subMethod.getReturnType());
- ResolvedType superType = weaver.getWorld().resolve(superMethod.getReturnType());
- if (!superType.isAssignableFrom(subType)) {
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- "The return type is incompatible with " + superMethod.getDeclaringType() + "." + superMethod.getName()
- + superMethod.getParameterSignature(), subMethod.getSourceLocation()));
-// this just might be a better error message...
-// "The return type '"+subReturnTypeSig+"' is incompatible with the overridden method "+superMethod.getDeclaringType()+"."+
-// superMethod.getName()+superMethod.getParameterSignature()+" which returns '"+superReturnTypeSig+"'",
- cont=false;
- }
- }
- return cont;
- }
-
- /**
- * Rule5. Method overrides can't change the staticality (word?) - you can't override and make an instance
- * method static or override and make a static method an instance method.
- */
- private boolean enforceDecpRule5_cantChangeFromStaticToNonstatic(BcelClassWeaver weaver,ISourceLocation mungerLoc,ResolvedMember superMethod, LazyMethodGen subMethod ) {
- if (superMethod.isStatic() && !subMethod.isStatic()) {
- error(weaver,"This instance method "+subMethod.getName()+subMethod.getParameterSignature()+
- " cannot override the static method from "+superMethod.getDeclaringType().getName(),
- subMethod.getSourceLocation(),new ISourceLocation[]{mungerLoc});
- return false;
- } else if (!superMethod.isStatic() && subMethod.isStatic()) {
- error(weaver,"The static method "+subMethod.getName()+subMethod.getParameterSignature()+
- " cannot hide the instance method from "+superMethod.getDeclaringType().getName(),
- subMethod.getSourceLocation(),new ISourceLocation[]{mungerLoc});
- return false;
- }
- return true;
- }
-
- public void error(BcelClassWeaver weaver,String text,ISourceLocation primaryLoc,ISourceLocation[] extraLocs) {
- IMessage msg = new Message(text, primaryLoc, true, extraLocs);
- weaver.getWorld().getMessageHandler().handleMessage(msg);
- }
-
-
- /**
- * Search the specified type for a particular method - do not use the return value in the comparison as it is not
- * considered for overriding.
- */
+
+ /**
+ * Rule5. Method overrides can't change the staticality (word?) - you can't override and make an instance method static or
+ * override and make a static method an instance method.
+ */
+ private boolean enforceDecpRule5_cantChangeFromStaticToNonstatic(BcelClassWeaver weaver, ISourceLocation mungerLoc,
+ ResolvedMember superMethod, LazyMethodGen subMethod) {
+ if (superMethod.isStatic() && !subMethod.isStatic()) {
+ error(weaver, "This instance method " + subMethod.getName() + subMethod.getParameterSignature()
+ + " cannot override the static method from " + superMethod.getDeclaringType().getName(), subMethod
+ .getSourceLocation(), new ISourceLocation[] { mungerLoc });
+ return false;
+ } else if (!superMethod.isStatic() && subMethod.isStatic()) {
+ error(weaver, "The static method " + subMethod.getName() + subMethod.getParameterSignature()
+ + " cannot hide the instance method from " + superMethod.getDeclaringType().getName(), subMethod
+ .getSourceLocation(), new ISourceLocation[] { mungerLoc });
+ return false;
+ }
+ return true;
+ }
+
+ public void error(BcelClassWeaver weaver, String text, ISourceLocation primaryLoc, ISourceLocation[] extraLocs) {
+ IMessage msg = new Message(text, primaryLoc, true, extraLocs);
+ weaver.getWorld().getMessageHandler().handleMessage(msg);
+ }
+
+ /**
+ * Search the specified type for a particular method - do not use the return value in the comparison as it is not considered for
+ * overriding.
+ */
private LazyMethodGen findMatchingMethod(LazyClassGen newParentTarget, ResolvedMember m) {
- LazyMethodGen found = null;
- List methodGens = newParentTarget.getMethodGens();
- for (Iterator i = methodGens.iterator(); i.hasNext() && found == null;) {
- LazyMethodGen gen = (LazyMethodGen) i.next();
- if (gen.getName().equals(m.getName()) &&
- gen.getParameterSignature().equals(m.getParameterSignature())) {
- found = gen;
- }
- }
+ LazyMethodGen found = null;
+ List methodGens = newParentTarget.getMethodGens();
+ for (Iterator i = methodGens.iterator(); i.hasNext() && found == null;) {
+ LazyMethodGen gen = (LazyMethodGen) i.next();
+ if (gen.getName().equals(m.getName()) && gen.getParameterSignature().equals(m.getParameterSignature())) {
+ found = gen;
+ }
+ }
return found;
}
- /**
- * The main part of implementing declare parents extends. Modify super ctor calls to target the new type.
- */
- public boolean attemptToModifySuperCalls(BcelClassWeaver weaver,LazyClassGen newParentTarget, ResolvedType newParent) {
- String currentParent = newParentTarget.getSuperClassname();
- if (newParent.getGenericType()!=null) newParent = newParent.getGenericType(); // target new super calls at the generic type if its raw or parameterized
- List mgs = newParentTarget.getMethodGens();
-
- // Look for ctors to modify
- for (Iterator iter = mgs.iterator(); iter.hasNext();) {
- LazyMethodGen aMethod = (LazyMethodGen) iter.next();
-
- if (aMethod.getName().equals("<init>")) {
- InstructionList insList = aMethod.getBody();
- InstructionHandle handle = insList.getStart();
- while (handle!= null) {
- if (handle.getInstruction().opcode==Constants.INVOKESPECIAL) {
- ConstantPool cpg = newParentTarget.getConstantPool();
- InvokeInstruction invokeSpecial = (InvokeInstruction)handle.getInstruction();
- if (invokeSpecial.getClassName(cpg).equals(currentParent) && invokeSpecial.getMethodName(cpg).equals("<init>")) {
- // System.err.println("Transforming super call '<init>"+sp.getSignature(cpg)+"'");
-
- // 1. Check there is a ctor in the new parent with the same signature
- ResolvedMember newCtor = getConstructorWithSignature(newParent,invokeSpecial.getSignature(cpg));
-
- if (newCtor == null) {
-
- // 2. Check ITDCs to see if the necessary ctor is provided that way
- boolean satisfiedByITDC = false;
- for (Iterator ii = newParentTarget.getType().getInterTypeMungersIncludingSupers().iterator(); ii.hasNext() && !satisfiedByITDC; ) {
- ConcreteTypeMunger m = (ConcreteTypeMunger)ii.next();
- if (m.getMunger() instanceof NewConstructorTypeMunger) {
- if (m.getSignature().getSignature().equals(invokeSpecial.getSignature(cpg))) {
- satisfiedByITDC = true;
- }
- }
- }
-
- if (!satisfiedByITDC) {
- String csig = createReadableCtorSig(newParent, cpg, invokeSpecial);
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- "Unable to modify hierarchy for "+newParentTarget.getClassName()+" - the constructor "+
- csig+" is missing",this.getSourceLocation()));
- return false;
- }
- }
-
- int idx = cpg.addMethodref(newParent.getName(), invokeSpecial.getMethodName(cpg), invokeSpecial.getSignature(cpg));
- invokeSpecial.setIndex(idx);
- }
- }
- handle = handle.getNext();
- }
- }
- }
- return true;
- }
-
+ /**
+ * The main part of implementing declare parents extends. Modify super ctor calls to target the new type.
+ */
+ public boolean attemptToModifySuperCalls(BcelClassWeaver weaver, LazyClassGen newParentTarget, ResolvedType newParent) {
+ String currentParent = newParentTarget.getSuperClassname();
+ if (newParent.getGenericType() != null)
+ newParent = newParent.getGenericType(); // target new super calls at
+ // the generic type if its
+ // raw or parameterized
+ List mgs = newParentTarget.getMethodGens();
+
+ // Look for ctors to modify
+ for (Iterator iter = mgs.iterator(); iter.hasNext();) {
+ LazyMethodGen aMethod = (LazyMethodGen) iter.next();
+
+ if (aMethod.getName().equals("<init>")) {
+ InstructionList insList = aMethod.getBody();
+ InstructionHandle handle = insList.getStart();
+ while (handle != null) {
+ if (handle.getInstruction().opcode == Constants.INVOKESPECIAL) {
+ ConstantPool cpg = newParentTarget.getConstantPool();
+ InvokeInstruction invokeSpecial = (InvokeInstruction) handle.getInstruction();
+ if (invokeSpecial.getClassName(cpg).equals(currentParent)
+ && invokeSpecial.getMethodName(cpg).equals("<init>")) {
+ // System.err.println(
+ // "Transforming super call '<init>"
+ // +sp.getSignature(cpg)+"'");
+
+ // 1. Check there is a ctor in the new parent with
+ // the same signature
+ ResolvedMember newCtor = getConstructorWithSignature(newParent, invokeSpecial.getSignature(cpg));
+
+ if (newCtor == null) {
+
+ // 2. Check ITDCs to see if the necessary ctor
+ // is provided that way
+ boolean satisfiedByITDC = false;
+ for (Iterator ii = newParentTarget.getType().getInterTypeMungersIncludingSupers().iterator(); ii
+ .hasNext()
+ && !satisfiedByITDC;) {
+ ConcreteTypeMunger m = (ConcreteTypeMunger) ii.next();
+ if (m.getMunger() instanceof NewConstructorTypeMunger) {
+ if (m.getSignature().getSignature().equals(invokeSpecial.getSignature(cpg))) {
+ satisfiedByITDC = true;
+ }
+ }
+ }
+
+ if (!satisfiedByITDC) {
+ String csig = createReadableCtorSig(newParent, cpg, invokeSpecial);
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error("Unable to modify hierarchy for " + newParentTarget.getClassName()
+ + " - the constructor " + csig + " is missing", this.getSourceLocation()));
+ return false;
+ }
+ }
+
+ int idx = cpg.addMethodref(newParent.getName(), invokeSpecial.getMethodName(cpg), invokeSpecial
+ .getSignature(cpg));
+ invokeSpecial.setIndex(idx);
+ }
+ }
+ handle = handle.getNext();
+ }
+ }
+ }
+ return true;
+ }
/**
- * Creates a nice signature for the ctor, something like "(int,Integer,String)"
+ * Creates a nice signature for the ctor, something like "(int,Integer,String)"
*/
private String createReadableCtorSig(ResolvedType newParent, ConstantPool cpg, InvokeInstruction invokeSpecial) {
- StringBuffer sb = new StringBuffer();
+ StringBuffer sb = new StringBuffer();
Type[] ctorArgs = invokeSpecial.getArgumentTypes(cpg);
- sb.append(newParent.getClassName());
- sb.append("(");
- for (int i = 0; i < ctorArgs.length; i++) {
+ sb.append(newParent.getClassName());
+ sb.append("(");
+ for (int i = 0; i < ctorArgs.length; i++) {
String argtype = ctorArgs[i].toString();
- if (argtype.lastIndexOf(".")!=-1)
- sb.append(argtype.substring(argtype.lastIndexOf(".")+1));
+ if (argtype.lastIndexOf(".") != -1)
+ sb.append(argtype.substring(argtype.lastIndexOf(".") + 1));
else
sb.append(argtype);
- if (i+1<ctorArgs.length) sb.append(",");
- }
- sb.append(")");
- return sb.toString();
+ if (i + 1 < ctorArgs.length)
+ sb.append(",");
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ private ResolvedMember getConstructorWithSignature(ResolvedType tx, String signature) {
+ ResolvedMember[] mems = tx.getDeclaredJavaMethods();
+ for (int i = 0; i < mems.length; i++) {
+ ResolvedMember rm = mems[i];
+ if (rm.getName().equals("<init>")) {
+ if (rm.getSignature().equals(signature))
+ return rm;
+ }
+ }
+ return null;
}
- private ResolvedMember getConstructorWithSignature(ResolvedType tx,String signature) {
- ResolvedMember[] mems = tx.getDeclaredJavaMethods();
- for (int i = 0; i < mems.length; i++) {
- ResolvedMember rm = mems[i];
- if (rm.getName().equals("<init>")) {
- if (rm.getSignature().equals(signature)) return rm;
- }
- }
- return null;
- }
-
-
- private boolean mungePrivilegedAccess(
- BcelClassWeaver weaver,
- PrivilegedAccessMunger munger)
- {
+ private boolean mungePrivilegedAccess(BcelClassWeaver weaver, PrivilegedAccessMunger munger) {
LazyClassGen gen = weaver.getLazyClassGen();
ResolvedMember member = munger.getMember();
-
- ResolvedType onType = weaver.getWorld().resolve(member.getDeclaringType(),munger.getSourceLocation());
- if (onType.isRawType()) onType = onType.getGenericType();
- //System.out.println("munging: " + gen + " with " + member);
+ ResolvedType onType = weaver.getWorld().resolve(member.getDeclaringType(), munger.getSourceLocation());
+ if (onType.isRawType())
+ onType = onType.getGenericType();
+
+ // System.out.println("munging: " + gen + " with " + member);
if (onType.equals(gen.getType())) {
if (member.getKind() == Member.FIELD) {
- //System.out.println("matched: " + gen);
- addFieldGetter(gen, member,
- AjcMemberMaker.privilegedAccessMethodForFieldGet(aspectType, member));
- addFieldSetter(gen, member,
- AjcMemberMaker.privilegedAccessMethodForFieldSet(aspectType, member));
+ // System.out.println("matched: " + gen);
+ addFieldGetter(gen, member, AjcMemberMaker.privilegedAccessMethodForFieldGet(aspectType, member));
+ addFieldSetter(gen, member, AjcMemberMaker.privilegedAccessMethodForFieldSet(aspectType, member));
return true;
} else if (member.getKind() == Member.METHOD) {
- addMethodDispatch(gen, member,
- AjcMemberMaker.privilegedAccessMethodForMethod(aspectType, member));
+ addMethodDispatch(gen, member, AjcMemberMaker.privilegedAccessMethodForMethod(aspectType, member));
return true;
} else if (member.getKind() == Member.CONSTRUCTOR) {
- for (Iterator i = gen.getMethodGens().iterator(); i.hasNext(); ) {
- LazyMethodGen m = (LazyMethodGen)i.next();
- if (m.getMemberView() != null
- && m.getMemberView().getKind() == Member.CONSTRUCTOR) {
+ for (Iterator i = gen.getMethodGens().iterator(); i.hasNext();) {
+ LazyMethodGen m = (LazyMethodGen) i.next();
+ if (m.getMemberView() != null && m.getMemberView().getKind() == Member.CONSTRUCTOR) {
// m.getMemberView().equals(member)) {
m.forcePublic();
- //return true;
+ // return true;
}
}
return true;
- //throw new BCException("no match for " + member + " in " + gen);
+ // throw new BCException("no match for " + member + " in " +
+ // gen);
} else if (member.getKind() == Member.STATIC_INITIALIZATION) {
gen.forcePublic();
return true;
return false;
}
- private void addFieldGetter(
- LazyClassGen gen,
- ResolvedMember field,
- ResolvedMember accessMethod)
- {
+ private void addFieldGetter(LazyClassGen gen, ResolvedMember field, ResolvedMember accessMethod) {
LazyMethodGen mg = makeMethodGen(gen, accessMethod);
InstructionList il = new InstructionList();
InstructionFactory fact = gen.getFactory();
if (field.isStatic()) {
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- field.getName(),
- BcelWorld.makeBcelType(field.getType()), Constants.GETSTATIC));
+ il.append(fact.createFieldAccess(gen.getClassName(), field.getName(), BcelWorld.makeBcelType(field.getType()),
+ Constants.GETSTATIC));
} else {
il.append(InstructionConstants.ALOAD_0);
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- field.getName(),
- BcelWorld.makeBcelType(field.getType()), Constants.GETFIELD));
+ il.append(fact.createFieldAccess(gen.getClassName(), field.getName(), BcelWorld.makeBcelType(field.getType()),
+ Constants.GETFIELD));
}
il.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(field.getType())));
mg.getBody().insert(il);
-
- gen.addMethodGen(mg,getSignature().getSourceLocation());
+
+ gen.addMethodGen(mg, getSignature().getSourceLocation());
}
-
- private void addFieldSetter(
- LazyClassGen gen,
- ResolvedMember field,
- ResolvedMember accessMethod)
- {
+
+ private void addFieldSetter(LazyClassGen gen, ResolvedMember field, ResolvedMember accessMethod) {
LazyMethodGen mg = makeMethodGen(gen, accessMethod);
InstructionList il = new InstructionList();
InstructionFactory fact = gen.getFactory();
Type fieldType = BcelWorld.makeBcelType(field.getType());
-
+
if (field.isStatic()) {
il.append(InstructionFactory.createLoad(fieldType, 0));
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- field.getName(),
- fieldType, Constants.PUTSTATIC));
+ il.append(fact.createFieldAccess(gen.getClassName(), field.getName(), fieldType, Constants.PUTSTATIC));
} else {
il.append(InstructionConstants.ALOAD_0);
il.append(InstructionFactory.createLoad(fieldType, 1));
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- field.getName(),
- fieldType, Constants.PUTFIELD));
+ il.append(fact.createFieldAccess(gen.getClassName(), field.getName(), fieldType, Constants.PUTFIELD));
}
il.append(InstructionFactory.createReturn(Type.VOID));
mg.getBody().insert(il);
-
- gen.addMethodGen(mg,getSignature().getSourceLocation());
+
+ gen.addMethodGen(mg, getSignature().getSourceLocation());
}
-
- private void addMethodDispatch(
- LazyClassGen gen,
- ResolvedMember method,
- ResolvedMember accessMethod)
- {
+
+ private void addMethodDispatch(LazyClassGen gen, ResolvedMember method, ResolvedMember accessMethod) {
LazyMethodGen mg = makeMethodGen(gen, accessMethod);
InstructionList il = new InstructionList();
InstructionFactory fact = gen.getFactory();
- //Type fieldType = BcelWorld.makeBcelType(field.getType());
+ // Type fieldType = BcelWorld.makeBcelType(field.getType());
Type[] paramTypes = BcelWorld.makeBcelTypes(method.getParameterTypes());
-
+
int pos = 0;
-
+
if (!method.isStatic()) {
il.append(InstructionConstants.ALOAD_0);
pos++;
for (int i = 0, len = paramTypes.length; i < len; i++) {
Type paramType = paramTypes[i];
il.append(InstructionFactory.createLoad(paramType, pos));
- pos+=paramType.getSize();
+ pos += paramType.getSize();
}
- il.append(Utility.createInvoke(fact, (BcelWorld)aspectType.getWorld(),
- method));
+ il.append(Utility.createInvoke(fact, (BcelWorld) aspectType.getWorld(), method));
il.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(method.getReturnType())));
mg.getBody().insert(il);
-
+
gen.addMethodGen(mg);
}
-
-
+
protected LazyMethodGen makeMethodGen(LazyClassGen gen, ResolvedMember member) {
- LazyMethodGen ret = new LazyMethodGen(
- member.getModifiers(),
- BcelWorld.makeBcelType(member.getReturnType()),
- member.getName(),
- BcelWorld.makeBcelTypes(member.getParameterTypes()),
- UnresolvedType.getNames(member.getExceptions()),
- gen);
-
- // 43972 : Static crosscutting makes interfaces unusable for javac
- // ret.makeSynthetic();
+ LazyMethodGen ret = new LazyMethodGen(member.getModifiers(), BcelWorld.makeBcelType(member.getReturnType()), member
+ .getName(), BcelWorld.makeBcelTypes(member.getParameterTypes()), UnresolvedType.getNames(member.getExceptions()),
+ gen);
+
+ // 43972 : Static crosscutting makes interfaces unusable for javac
+ // ret.makeSynthetic();
return ret;
}
-
protected FieldGen makeFieldGen(LazyClassGen gen, ResolvedMember member) {
- return new FieldGen(
- member.getModifiers(),
- BcelWorld.makeBcelType(member.getReturnType()),
- member.getName(),
- gen.getConstantPool());
+ return new FieldGen(member.getModifiers(), BcelWorld.makeBcelType(member.getReturnType()), member.getName(), gen
+ .getConstantPool());
}
-
-
-
- private boolean mungePerObjectInterface(
- BcelClassWeaver weaver,
- PerObjectInterfaceTypeMunger munger)
- {
- //System.err.println("Munging perobject ["+munger+"] onto "+weaver.getLazyClassGen().getClassName());
+ private boolean mungePerObjectInterface(BcelClassWeaver weaver, PerObjectInterfaceTypeMunger munger) {
+ // System.err.println("Munging perobject ["+munger+"] onto "+weaver.
+ // getLazyClassGen().getClassName());
LazyClassGen gen = weaver.getLazyClassGen();
-
+
if (couldMatch(gen.getBcelObjectType(), munger.getTestPointcut())) {
- FieldGen fg = makeFieldGen(gen,
- AjcMemberMaker.perObjectField(gen.getType(), aspectType));
-
- gen.addField(fg,getSourceLocation());
-
-
- Type fieldType = BcelWorld.makeBcelType(aspectType);
- LazyMethodGen mg = new LazyMethodGen(
- Modifier.PUBLIC,
- fieldType,
- NameMangler.perObjectInterfaceGet(aspectType),
- new Type[0], new String[0],
- gen);
+ FieldGen fg = makeFieldGen(gen, AjcMemberMaker.perObjectField(gen.getType(), aspectType));
+
+ gen.addField(fg, getSourceLocation());
+
+ Type fieldType = BcelWorld.makeBcelType(aspectType);
+ LazyMethodGen mg = new LazyMethodGen(Modifier.PUBLIC, fieldType, NameMangler.perObjectInterfaceGet(aspectType),
+ new Type[0], new String[0], gen);
InstructionList il = new InstructionList();
InstructionFactory fact = gen.getFactory();
il.append(InstructionConstants.ALOAD_0);
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.GETFIELD));
+ il.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.GETFIELD));
il.append(InstructionFactory.createReturn(fieldType));
mg.getBody().insert(il);
-
+
gen.addMethodGen(mg);
-
- LazyMethodGen mg1 = new LazyMethodGen(
- Modifier.PUBLIC,
- Type.VOID,
- NameMangler.perObjectInterfaceSet(aspectType),
-
- new Type[]{fieldType,}, new String[0],
- gen);
+
+ LazyMethodGen mg1 = new LazyMethodGen(Modifier.PUBLIC, Type.VOID, NameMangler.perObjectInterfaceSet(aspectType),
+
+ new Type[] { fieldType, }, new String[0], gen);
InstructionList il1 = new InstructionList();
il1.append(InstructionConstants.ALOAD_0);
il1.append(InstructionFactory.createLoad(fieldType, 1));
- il1.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.PUTFIELD));
+ il1.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.PUTFIELD));
il1.append(InstructionFactory.createReturn(Type.VOID));
mg1.getBody().insert(il1);
-
+
gen.addMethodGen(mg1);
-
- gen.addInterface(munger.getInterfaceType(),getSourceLocation());
+
+ gen.addInterface(munger.getInterfaceType(), getSourceLocation());
return true;
} else {
return false;
}
}
-
+
// PTWIMPL Add field to hold aspect instance and an accessor
private boolean mungePerTypeWithinTransformer(BcelClassWeaver weaver) {
LazyClassGen gen = weaver.getLazyClassGen();
-
+
// if (couldMatch(gen.getBcelObjectType(), munger.getTestPointcut())) {
-
- // Add (to the target type) the field that will hold the aspect instance
- // e.g ajc$com_blah_SecurityAspect$ptwAspectInstance
- FieldGen fg = makeFieldGen(gen, AjcMemberMaker.perTypeWithinField(gen.getType(), aspectType));
- gen.addField(fg,getSourceLocation());
-
- // Add an accessor for this new field, the ajc$<aspectname>$localAspectOf() method
- // e.g. "public com_blah_SecurityAspect ajc$com_blah_SecurityAspect$localAspectOf()"
- Type fieldType = BcelWorld.makeBcelType(aspectType);
- LazyMethodGen mg = new LazyMethodGen(
- Modifier.PUBLIC | Modifier.STATIC,fieldType,
- NameMangler.perTypeWithinLocalAspectOf(aspectType),
- new Type[0], new String[0],gen);
- InstructionList il = new InstructionList();
- //PTWIMPL ?? Should check if it is null and throw NoAspectBoundException
- InstructionFactory fact = gen.getFactory();
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.GETSTATIC));
- il.append(InstructionFactory.createReturn(fieldType));
- mg.getBody().insert(il);
- gen.addMethodGen(mg);
- return true;
-// } else {
-// return false;
-// }
+
+ // Add (to the target type) the field that will hold the aspect instance
+ // e.g ajc$com_blah_SecurityAspect$ptwAspectInstance
+ FieldGen fg = makeFieldGen(gen, AjcMemberMaker.perTypeWithinField(gen.getType(), aspectType));
+ gen.addField(fg, getSourceLocation());
+
+ // Add an accessor for this new field, the
+ // ajc$<aspectname>$localAspectOf() method
+ // e.g.
+ // "public com_blah_SecurityAspect ajc$com_blah_SecurityAspect$localAspectOf()"
+ Type fieldType = BcelWorld.makeBcelType(aspectType);
+ LazyMethodGen mg = new LazyMethodGen(Modifier.PUBLIC | Modifier.STATIC, fieldType, NameMangler
+ .perTypeWithinLocalAspectOf(aspectType), new Type[0], new String[0], gen);
+ InstructionList il = new InstructionList();
+ // PTWIMPL ?? Should check if it is null and throw
+ // NoAspectBoundException
+ InstructionFactory fact = gen.getFactory();
+ il.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.GETSTATIC));
+ il.append(InstructionFactory.createReturn(fieldType));
+ mg.getBody().insert(il);
+ gen.addMethodGen(mg);
+ return true;
+ // } else {
+ // return false;
+ // }
}
- // ??? Why do we have this method? I thought by now we would know if it matched or not
- private boolean couldMatch(
- BcelObjectType bcelObjectType,
- Pointcut pointcut) {
+ // ??? Why do we have this method? I thought by now we would know if it
+ // matched or not
+ private boolean couldMatch(BcelObjectType bcelObjectType, Pointcut pointcut) {
return !bcelObjectType.isInterface();
}
-
+
private boolean mungeNewMethod(BcelClassWeaver weaver, NewMethodTypeMunger munger) {
World w = weaver.getWorld();
// Resolving it will sort out the tvars
ResolvedMember unMangledInterMethod = munger.getSignature().resolve(w);
- // do matching on the unMangled one, but actually add them to the mangled method
- ResolvedMember interMethodBody = munger.getDeclaredInterMethodBody(aspectType,w);
- ResolvedMember interMethodDispatcher = munger.getDeclaredInterMethodDispatcher(aspectType,w);
+ // do matching on the unMangled one, but actually add them to the
+ // mangled method
+ ResolvedMember interMethodBody = munger.getDeclaredInterMethodBody(aspectType, w);
+ ResolvedMember interMethodDispatcher = munger.getDeclaredInterMethodDispatcher(aspectType, w);
ResolvedMember memberHoldingAnyAnnotations = interMethodDispatcher;
- ResolvedType onType = weaver.getWorld().resolve(unMangledInterMethod.getDeclaringType(),munger.getSourceLocation());
+ ResolvedType onType = weaver.getWorld().resolve(unMangledInterMethod.getDeclaringType(), munger.getSourceLocation());
LazyClassGen gen = weaver.getLazyClassGen();
boolean mungingInterface = gen.isInterface();
-
- if (onType.isRawType()) onType = onType.getGenericType();
+
+ if (onType.isRawType())
+ onType = onType.getGenericType();
boolean onInterface = onType.isInterface();
-
-
+
// Simple checks, can't ITD on annotations or enums
if (onType.isAnnotation()) {
- signalError(WeaverMessages.ITDM_ON_ANNOTATION_NOT_ALLOWED,weaver,onType);
- return false;
+ signalError(WeaverMessages.ITDM_ON_ANNOTATION_NOT_ALLOWED, weaver, onType);
+ return false;
}
-
+
if (onType.isEnum()) {
- signalError(WeaverMessages.ITDM_ON_ENUM_NOT_ALLOWED,weaver,onType);
+ signalError(WeaverMessages.ITDM_ON_ENUM_NOT_ALLOWED, weaver, onType);
return false;
}
-
- if (onInterface && gen.getLazyMethodGen(unMangledInterMethod.getName(), unMangledInterMethod.getSignature(),true) != null) {
- // this is ok, we could be providing the default implementation of a method
- // that the target has already declared
- return false;
+
+ if (onInterface && gen.getLazyMethodGen(unMangledInterMethod.getName(), unMangledInterMethod.getSignature(), true) != null) {
+ // this is ok, we could be providing the default implementation of a
+ // method
+ // that the target has already declared
+ return false;
}
-
- // If we are processing the intended ITD target type (might be an interface)
+
+ // If we are processing the intended ITD target type (might be an
+ // interface)
if (onType.equals(gen.getType())) {
- ResolvedMember mangledInterMethod =
- AjcMemberMaker.interMethod(unMangledInterMethod, aspectType, onInterface);
-
-
+ ResolvedMember mangledInterMethod = AjcMemberMaker.interMethod(unMangledInterMethod, aspectType, onInterface);
+
LazyMethodGen newMethod = makeMethodGen(gen, mangledInterMethod);
if (mungingInterface) {
- // we want the modifiers of the ITD to be used for all *implementors* of the
- // interface, but the method itself we add to the interface must be public abstract
+ // we want the modifiers of the ITD to be used for all
+ // *implementors* of the
+ // interface, but the method itself we add to the interface must
+ // be public abstract
newMethod.setAccessFlags(Modifier.PUBLIC | Modifier.ABSTRACT);
}
-
+
// pr98901
- // For copying the annotations across, we have to discover the real member in the aspect
- // which is holding them.
- if (weaver.getWorld().isInJava5Mode()){
- AnnotationX annotationsOnRealMember[] = null;
+ // For copying the annotations across, we have to discover the real
+ // member in the aspect
+ // which is holding them.
+ if (weaver.getWorld().isInJava5Mode()) {
+ AnnotationAJ annotationsOnRealMember[] = null;
ResolvedType toLookOn = aspectType;
- if (aspectType.isRawType()) toLookOn = aspectType.getGenericType();
- ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn,memberHoldingAnyAnnotations,false);
- if (realMember==null) throw new BCException("Couldn't find ITD holder member '"+
- memberHoldingAnyAnnotations+"' on aspect "+aspectType);
+ if (aspectType.isRawType())
+ toLookOn = aspectType.getGenericType();
+ ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn, memberHoldingAnyAnnotations, false);
+ if (realMember == null)
+ throw new BCException("Couldn't find ITD holder member '" + memberHoldingAnyAnnotations + "' on aspect "
+ + aspectType);
annotationsOnRealMember = realMember.getAnnotations();
-
- if (annotationsOnRealMember!=null) {
+
+ if (annotationsOnRealMember != null) {
for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
- newMethod.addAnnotation(new AnnotationX(ag,weaver.getWorld()));
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
+ newMethod.addAnnotation(new BcelAnnotation(ag, weaver.getWorld()));
}
}
// the below loop fixes the very special (and very stupid)
// case where an aspect declares an annotation
// on an ITD it declared on itself.
List allDecams = weaver.getWorld().getDeclareAnnotationOnMethods();
- for (Iterator i = allDecams.iterator(); i.hasNext();){
- DeclareAnnotation decaMC = (DeclareAnnotation) i.next();
- if (decaMC.matches(unMangledInterMethod,weaver.getWorld())
+ for (Iterator i = allDecams.iterator(); i.hasNext();) {
+ DeclareAnnotation decaMC = (DeclareAnnotation) i.next();
+ if (decaMC.matches(unMangledInterMethod, weaver.getWorld())
&& newMethod.getEnclosingClass().getType() == aspectType) {
newMethod.addAnnotation(decaMC.getAnnotationX());
}
}
}
- // If it doesn't target an interface and there is a body (i.e. it isnt abstract)
+ // If it doesn't target an interface and there is a body (i.e. it
+ // isnt abstract)
if (!onInterface && !Modifier.isAbstract(mangledInterMethod.getModifiers())) {
InstructionList body = newMethod.getBody();
InstructionFactory fact = gen.getFactory();
int pos = 0;
-
+
if (!unMangledInterMethod.isStatic()) {
body.append(InstructionFactory.createThis());
pos++;
for (int i = 0, len = paramTypes.length; i < len; i++) {
Type paramType = paramTypes[i];
body.append(InstructionFactory.createLoad(paramType, pos));
- pos+=paramType.getSize();
+ pos += paramType.getSize();
}
body.append(Utility.createInvoke(fact, weaver.getWorld(), interMethodBody));
- body.append(
- InstructionFactory.createReturn(
- BcelWorld.makeBcelType(mangledInterMethod.getReturnType())));
-
- if (weaver.getWorld().isInJava5Mode()) { // Don't need bridge methods if not in 1.5 mode.
+ body.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(mangledInterMethod.getReturnType())));
+
+ if (weaver.getWorld().isInJava5Mode()) { // Don't need bridge
+ // methods if not in
+ // 1.5 mode.
createAnyBridgeMethodsForCovariance(weaver, munger, unMangledInterMethod, onType, gen, paramTypes);
}
-
+
} else {
- //??? this is okay
- //if (!(mg.getBody() == null)) throw new RuntimeException("bas");
+ // ??? this is okay
+ // if (!(mg.getBody() == null)) throw new
+ // RuntimeException("bas");
}
-
- if (weaver.getWorld().isInJava5Mode()){
+ if (weaver.getWorld().isInJava5Mode()) {
String basicSignature = mangledInterMethod.getSignature();
- String genericSignature = ((ResolvedMemberImpl)mangledInterMethod).getSignatureForAttribute();
+ String genericSignature = ((ResolvedMemberImpl) mangledInterMethod).getSignatureForAttribute();
if (!basicSignature.equals(genericSignature)) {
// Add a signature attribute to it
- newMethod.addAttribute(createSignatureAttribute(gen.getConstantPool(),genericSignature));
+ newMethod.addAttribute(createSignatureAttribute(gen.getConstantPool(), genericSignature));
}
}
- // XXX make sure to check that we set exceptions properly on this guy.
+ // XXX make sure to check that we set exceptions properly on this
+ // guy.
weaver.addLazyMethodGen(newMethod);
- weaver.getLazyClassGen().warnOnAddedMethod(newMethod.getMethod(),getSignature().getSourceLocation());
-
+ weaver.getLazyClassGen().warnOnAddedMethod(newMethod.getMethod(), getSignature().getSourceLocation());
+
addNeededSuperCallMethods(weaver, onType, munger.getSuperMethodsCalled());
-
- return true;
-
+
+ return true;
+
} else if (onInterface && !Modifier.isAbstract(unMangledInterMethod.getModifiers())) {
-
+
// This means the 'gen' should be the top most implementor
// - if it is *not* then something went wrong after we worked
// out that it was the top most implementor (see pr49657)
- if (!gen.getType().isTopmostImplementor(onType)) {
- ResolvedType rtx = gen.getType().getTopmostImplementor(onType);
- if (!rtx.isExposedToWeaver()) {
- ISourceLocation sLoc = munger.getSourceLocation();
- weaver.getWorld().getMessageHandler().handleMessage(MessageUtil.error(
- WeaverMessages.format(WeaverMessages.ITD_NON_EXPOSED_IMPLEMENTOR,rtx,getAspectType().getName()),
- (sLoc==null?getAspectType().getSourceLocation():sLoc)));
- } else {
- // XXX what does this state mean?
- // We have incorrectly identified what is the top most implementor and its not because
- // a type wasn't exposed to the weaver
- }
+ if (!gen.getType().isTopmostImplementor(onType)) {
+ ResolvedType rtx = gen.getType().getTopmostImplementor(onType);
+ if (!rtx.isExposedToWeaver()) {
+ ISourceLocation sLoc = munger.getSourceLocation();
+ weaver.getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_NON_EXPOSED_IMPLEMENTOR, rtx,
+ getAspectType().getName()), (sLoc == null ? getAspectType().getSourceLocation() : sLoc)));
+ } else {
+ // XXX what does this state mean?
+ // We have incorrectly identified what is the top most
+ // implementor and its not because
+ // a type wasn't exposed to the weaver
+ }
return false;
- } else {
-
- ResolvedMember mangledInterMethod =
- AjcMemberMaker.interMethod(unMangledInterMethod, aspectType, false);
-
- LazyMethodGen mg = makeMethodGen(gen, mangledInterMethod);
-
- // From 98901#29 - need to copy annotations across
- if (weaver.getWorld().isInJava5Mode()){
- AnnotationX annotationsOnRealMember[] = null;
+ } else {
+
+ ResolvedMember mangledInterMethod = AjcMemberMaker.interMethod(unMangledInterMethod, aspectType, false);
+
+ LazyMethodGen mg = makeMethodGen(gen, mangledInterMethod);
+
+ // From 98901#29 - need to copy annotations across
+ if (weaver.getWorld().isInJava5Mode()) {
+ AnnotationAJ annotationsOnRealMember[] = null;
ResolvedType toLookOn = aspectType;
- if (aspectType.isRawType()) toLookOn = aspectType.getGenericType();
- ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn,memberHoldingAnyAnnotations,false);
- if (realMember==null) throw new BCException("Couldn't find ITD holder member '"+
- memberHoldingAnyAnnotations+"' on aspect "+aspectType);
+ if (aspectType.isRawType())
+ toLookOn = aspectType.getGenericType();
+ ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn, memberHoldingAnyAnnotations, false);
+ if (realMember == null)
+ throw new BCException("Couldn't find ITD holder member '" + memberHoldingAnyAnnotations + "' on aspect "
+ + aspectType);
annotationsOnRealMember = realMember.getAnnotations();
-
- if (annotationsOnRealMember!=null) {
+
+ if (annotationsOnRealMember != null) {
for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
- mg.addAnnotation(new AnnotationX(ag,weaver.getWorld()));
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
+ mg.addAnnotation(new BcelAnnotation(ag, weaver.getWorld()));
}
}
- }
-
- if (mungingInterface) {
- // we want the modifiers of the ITD to be used for all *implementors* of the
- // interface, but the method itself we add to the interface must be public abstract
- mg.setAccessFlags(Modifier.PUBLIC | Modifier.ABSTRACT);
- }
-
- Type[] paramTypes = BcelWorld.makeBcelTypes(mangledInterMethod.getParameterTypes());
- Type returnType = BcelWorld.makeBcelType(mangledInterMethod.getReturnType());
-
- InstructionList body = mg.getBody();
- InstructionFactory fact = gen.getFactory();
- int pos = 0;
-
- if (!mangledInterMethod.isStatic()) {
- body.append(InstructionFactory.createThis());
- pos++;
- }
- for (int i = 0, len = paramTypes.length; i < len; i++) {
- Type paramType = paramTypes[i];
- body.append(InstructionFactory.createLoad(paramType, pos));
- pos+=paramType.getSize();
- }
-
- body.append(Utility.createInvoke(fact, weaver.getWorld(), interMethodBody));
- Type t= BcelWorld.makeBcelType(interMethodBody.getReturnType());
- if (!t.equals(returnType)) {
- body.append(fact.createCast(t,returnType));
- }
- body.append(InstructionFactory.createReturn(returnType));
- mg.definingType = onType;
-
-
- if (weaver.getWorld().isInJava5Mode()) {
- String basicSignature = mangledInterMethod.getSignature();
- String genericSignature = ((ResolvedMemberImpl)mangledInterMethod).getSignatureForAttribute();
- if (!basicSignature.equals(genericSignature)) {
- // Add a signature attribute to it
- mg.addAttribute(createSignatureAttribute(gen.getConstantPool(),genericSignature));
- }
- }
-
- weaver.addOrReplaceLazyMethodGen(mg);
-
- addNeededSuperCallMethods(weaver, onType, munger.getSuperMethodsCalled());
-
- // Work out if we need a bridge method for the new method added to the topmostimplementor.
- if (munger.getDeclaredSignature()!=null) { // Check if the munger being processed is a parameterized form of some original munger.
- boolean needsbridging = false;
- ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,munger.getSignature().getDeclaringType().resolve(getWorld()),false,munger.getTypeVariableAliases());
- if (!toBridgeTo.getReturnType().getErasureSignature().equals(munger.getSignature().getReturnType().getErasureSignature())) needsbridging = true;
- UnresolvedType[] originalParams = toBridgeTo.getParameterTypes();
- UnresolvedType[] newParams = munger.getSignature().getParameterTypes();
- for (int ii = 0;ii<originalParams.length;ii++) {
- if (!originalParams[ii].getErasureSignature().equals(newParams[ii].getErasureSignature())) needsbridging=true;
}
- if (needsbridging) {
- ResolvedMember bridgerMethod = AjcMemberMaker.bridgerToInterMethod(unMangledInterMethod,gen.getType());
- ResolvedMember bridgingSetter = AjcMemberMaker.interMethod(toBridgeTo, aspectType, false);
-
- // FIXME asc ----------------8<---------------- extract method
- LazyMethodGen bridgeMethod = makeMethodGen(gen,bridgingSetter);
- paramTypes = BcelWorld.makeBcelTypes(bridgingSetter.getParameterTypes());
- Type[] bridgingToParms = BcelWorld.makeBcelTypes(unMangledInterMethod.getParameterTypes());
- returnType = BcelWorld.makeBcelType(bridgingSetter.getReturnType());
- body = bridgeMethod.getBody();
- fact = gen.getFactory();
- pos = 0;
-
- if (!bridgingSetter.isStatic()) {
- body.append(InstructionFactory.createThis());
- pos++;
- }
- for (int i = 0, len = paramTypes.length; i < len; i++) {
- Type paramType = paramTypes[i];
- body.append(InstructionFactory.createLoad(paramType, pos));
- if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals(unMangledInterMethod.getParameterTypes()[i].getErasureSignature()) ) {
-// System.err.println("Putting in cast from "+paramType+" to "+bridgingToParms[i]);
- body.append(fact.createCast(paramType,bridgingToParms[i]));
- }
- pos+=paramType.getSize();
- }
-
- body.append(Utility.createInvoke(fact, weaver.getWorld(), bridgerMethod));
- body.append(InstructionFactory.createReturn(returnType));
- gen.addMethodGen(bridgeMethod);
-// mg.definingType = onType;
- // FIXME asc (see above) ---------------------8<--------------- extract method
+
+ if (mungingInterface) {
+ // we want the modifiers of the ITD to be used for all
+ // *implementors* of the
+ // interface, but the method itself we add to the interface
+ // must be public abstract
+ mg.setAccessFlags(Modifier.PUBLIC | Modifier.ABSTRACT);
+ }
+
+ Type[] paramTypes = BcelWorld.makeBcelTypes(mangledInterMethod.getParameterTypes());
+ Type returnType = BcelWorld.makeBcelType(mangledInterMethod.getReturnType());
+
+ InstructionList body = mg.getBody();
+ InstructionFactory fact = gen.getFactory();
+ int pos = 0;
+
+ if (!mangledInterMethod.isStatic()) {
+ body.append(InstructionFactory.createThis());
+ pos++;
+ }
+ for (int i = 0, len = paramTypes.length; i < len; i++) {
+ Type paramType = paramTypes[i];
+ body.append(InstructionFactory.createLoad(paramType, pos));
+ pos += paramType.getSize();
+ }
+
+ body.append(Utility.createInvoke(fact, weaver.getWorld(), interMethodBody));
+ Type t = BcelWorld.makeBcelType(interMethodBody.getReturnType());
+ if (!t.equals(returnType)) {
+ body.append(fact.createCast(t, returnType));
}
-
- }
-
-
- return true;
- }
+ body.append(InstructionFactory.createReturn(returnType));
+ mg.definingType = onType;
+
+ if (weaver.getWorld().isInJava5Mode()) {
+ String basicSignature = mangledInterMethod.getSignature();
+ String genericSignature = ((ResolvedMemberImpl) mangledInterMethod).getSignatureForAttribute();
+ if (!basicSignature.equals(genericSignature)) {
+ // Add a signature attribute to it
+ mg.addAttribute(createSignatureAttribute(gen.getConstantPool(), genericSignature));
+ }
+ }
+
+ weaver.addOrReplaceLazyMethodGen(mg);
+
+ addNeededSuperCallMethods(weaver, onType, munger.getSuperMethodsCalled());
+
+ // Work out if we need a bridge method for the new method added
+ // to the topmostimplementor.
+ if (munger.getDeclaredSignature() != null) { // Check if the
+ // munger being
+ // processed is
+ // a
+ // parameterized
+ // form of some
+ // original
+ // munger.
+ boolean needsbridging = false;
+ ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,
+ munger.getSignature().getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases());
+ if (!toBridgeTo.getReturnType().getErasureSignature().equals(
+ munger.getSignature().getReturnType().getErasureSignature()))
+ needsbridging = true;
+ UnresolvedType[] originalParams = toBridgeTo.getParameterTypes();
+ UnresolvedType[] newParams = munger.getSignature().getParameterTypes();
+ for (int ii = 0; ii < originalParams.length; ii++) {
+ if (!originalParams[ii].getErasureSignature().equals(newParams[ii].getErasureSignature()))
+ needsbridging = true;
+ }
+ if (needsbridging) {
+ ResolvedMember bridgerMethod = AjcMemberMaker.bridgerToInterMethod(unMangledInterMethod, gen.getType());
+ ResolvedMember bridgingSetter = AjcMemberMaker.interMethod(toBridgeTo, aspectType, false);
+
+ // FIXME asc ----------------8<---------------- extract
+ // method
+ LazyMethodGen bridgeMethod = makeMethodGen(gen, bridgingSetter);
+ paramTypes = BcelWorld.makeBcelTypes(bridgingSetter.getParameterTypes());
+ Type[] bridgingToParms = BcelWorld.makeBcelTypes(unMangledInterMethod.getParameterTypes());
+ returnType = BcelWorld.makeBcelType(bridgingSetter.getReturnType());
+ body = bridgeMethod.getBody();
+ fact = gen.getFactory();
+ pos = 0;
+
+ if (!bridgingSetter.isStatic()) {
+ body.append(InstructionFactory.createThis());
+ pos++;
+ }
+ for (int i = 0, len = paramTypes.length; i < len; i++) {
+ Type paramType = paramTypes[i];
+ body.append(InstructionFactory.createLoad(paramType, pos));
+ if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals(
+ unMangledInterMethod.getParameterTypes()[i].getErasureSignature())) {
+ // System.err.println("Putting in cast from "+
+ // paramType+" to "+bridgingToParms[i]);
+ body.append(fact.createCast(paramType, bridgingToParms[i]));
+ }
+ pos += paramType.getSize();
+ }
+
+ body.append(Utility.createInvoke(fact, weaver.getWorld(), bridgerMethod));
+ body.append(InstructionFactory.createReturn(returnType));
+ gen.addMethodGen(bridgeMethod);
+ // mg.definingType = onType;
+ // FIXME asc (see above)
+ // ---------------------8<--------------- extract method
+ }
+
+ }
+
+ return true;
+ }
} else {
return false;
}
}
-
- /**
- * Helper method to create a signature attribute based on a string signature:
- * e.g. "Ljava/lang/Object;LI<Ljava/lang/Double;>;"
+
+ /**
+ * Helper method to create a signature attribute based on a string signature: e.g. "Ljava/lang/Object;LI<Ljava/lang/Double;>;"
*/
- private Signature createSignatureAttribute(ConstantPool cp,String signature) {
+ private Signature createSignatureAttribute(ConstantPool cp, String signature) {
int nameIndex = cp.addUtf8("Signature");
- int sigIndex = cp.addUtf8(signature);
- return new Signature(nameIndex,2,sigIndex,cp);
+ int sigIndex = cp.addUtf8(signature);
+ return new Signature(nameIndex, 2, sigIndex, cp);
}
-
+
/**
- * Create any bridge method required because of covariant returns being used. This method is used in the case
- * where an ITD is applied to some type and it may be in an override relationship with a method from the supertype - but
- * due to covariance there is a mismatch in return values.
- * Example of when required:
- Super defines: Object m(String s)
- Sub defines: String m(String s)
- then we need a bridge method in Sub called 'Object m(String s)' that forwards to 'String m(String s)'
+ * Create any bridge method required because of covariant returns being used. This method is used in the case where an ITD is
+ * applied to some type and it may be in an override relationship with a method from the supertype - but due to covariance there
+ * is a mismatch in return values. Example of when required: Super defines: Object m(String s) Sub defines: String m(String s)
+ * then we need a bridge method in Sub called 'Object m(String s)' that forwards to 'String m(String s)'
*/
- private void createAnyBridgeMethodsForCovariance(BcelClassWeaver weaver, NewMethodTypeMunger munger, ResolvedMember unMangledInterMethod, ResolvedType onType, LazyClassGen gen, Type[] paramTypes) {
- // PERFORMANCE BOTTLENECK? Might need investigating, method analysis between types in a hierarchy just seems expensive...
+ private void createAnyBridgeMethodsForCovariance(BcelClassWeaver weaver, NewMethodTypeMunger munger,
+ ResolvedMember unMangledInterMethod, ResolvedType onType, LazyClassGen gen, Type[] paramTypes) {
+ // PERFORMANCE BOTTLENECK? Might need investigating, method analysis
+ // between types in a hierarchy just seems expensive...
// COVARIANCE BRIDGING
- // Algorithm: Step1. Check in this type - has someone already created the bridge method?
- // Step2. Look above us - do we 'override' a method and yet differ in return type (i.e. covariance)
- // Step3. Create a forwarding bridge method
-// ResolvedType superclass = onType.getSuperclass();
+ // Algorithm: Step1. Check in this type - has someone already created
+ // the bridge method?
+ // Step2. Look above us - do we 'override' a method and yet differ in
+ // return type (i.e. covariance)
+ // Step3. Create a forwarding bridge method
+ // ResolvedType superclass = onType.getSuperclass();
boolean quitRightNow = false;
-
- String localMethodName = unMangledInterMethod.getName();
- String localParameterSig = unMangledInterMethod.getParameterSignature();
- String localReturnTypeESig = unMangledInterMethod.getReturnType().getErasureSignature();
+
+ String localMethodName = unMangledInterMethod.getName();
+ String localParameterSig = unMangledInterMethod.getParameterSignature();
+ String localReturnTypeESig = unMangledInterMethod.getReturnType().getErasureSignature();
// Step1
boolean alreadyDone = false; // Compiler might have done it
ResolvedMember member = localMethods[i];
if (member.getName().equals(localMethodName)) {
// Check the params
- if (member.getParameterSignature().equals(localParameterSig)) alreadyDone = true;
+ if (member.getParameterSignature().equals(localParameterSig))
+ alreadyDone = true;
}
}
-
+
// Step2
if (!alreadyDone) {
- // Use the iterator form of 'getMethods()' so we do as little work as necessary
- for (Iterator iter = onType.getSuperclass().getMethods();iter.hasNext() && !quitRightNow;) {
+ // Use the iterator form of 'getMethods()' so we do as little work
+ // as necessary
+ for (Iterator iter = onType.getSuperclass().getMethods(); iter.hasNext() && !quitRightNow;) {
ResolvedMember aMethod = (ResolvedMember) iter.next();
if (aMethod.getName().equals(localMethodName) && aMethod.getParameterSignature().equals(localParameterSig)) {
- // check the return types, if they are different we need a bridging method.
- if (!aMethod.getReturnType().getErasureSignature().equals(localReturnTypeESig) && !Modifier.isPrivate(aMethod.getModifiers())) {
+ // check the return types, if they are different we need a
+ // bridging method.
+ if (!aMethod.getReturnType().getErasureSignature().equals(localReturnTypeESig)
+ && !Modifier.isPrivate(aMethod.getModifiers())) {
// Step3
createBridgeMethod(weaver.getWorld(), munger, unMangledInterMethod, gen, paramTypes, aMethod);
quitRightNow = true;
}
/**
- * Create a bridge method for a particular munger.
+ * Create a bridge method for a particular munger.
+ *
* @param world
* @param munger
* @param unMangledInterMethod the method to bridge 'to' that we have already created in the 'subtype'
* @param clazz the class in which to put the bridge method
- * @param paramTypes Parameter types for the bridge method, passed in as an optimization since the caller is likely to have already created them.
- * @param theBridgeMethod
+ * @param paramTypes Parameter types for the bridge method, passed in as an optimization since the caller is likely to have
+ * already created them.
+ * @param theBridgeMethod
*/
- private void createBridgeMethod(BcelWorld world, NewMethodTypeMunger munger,
- ResolvedMember unMangledInterMethod, LazyClassGen clazz, Type[] paramTypes, ResolvedMember theBridgeMethod) {
+ private void createBridgeMethod(BcelWorld world, NewMethodTypeMunger munger, ResolvedMember unMangledInterMethod,
+ LazyClassGen clazz, Type[] paramTypes, ResolvedMember theBridgeMethod) {
InstructionList body;
InstructionFactory fact;
int pos = 0;
-
- LazyMethodGen bridgeMethod = makeMethodGen(clazz,theBridgeMethod); // The bridge method in this type will have the same signature as the one in the supertype
- bridgeMethod.setAccessFlags(bridgeMethod.getAccessFlags() | 0x00000040 /*BRIDGE = 0x00000040*/ );
-// UnresolvedType[] newParams = munger.getSignature().getParameterTypes();
- Type returnType = BcelWorld.makeBcelType(theBridgeMethod.getReturnType());
+
+ LazyMethodGen bridgeMethod = makeMethodGen(clazz, theBridgeMethod); // The
+ // bridge
+ // method
+ // in
+ // this
+ // type
+ // will
+ // have
+ // the
+ // same
+ // signature
+ // as
+ // the
+ // one
+ // in
+ // the
+ // supertype
+ bridgeMethod.setAccessFlags(bridgeMethod.getAccessFlags() | 0x00000040 /*
+ * BRIDGE = 0x00000040
+ */);
+ // UnresolvedType[] newParams =
+ // munger.getSignature().getParameterTypes();
+ Type returnType = BcelWorld.makeBcelType(theBridgeMethod.getReturnType());
body = bridgeMethod.getBody();
fact = clazz.getFactory();
if (!unMangledInterMethod.isStatic()) {
- body.append(InstructionFactory.createThis());
- pos++;
+ body.append(InstructionFactory.createThis());
+ pos++;
}
for (int i = 0, len = paramTypes.length; i < len; i++) {
- Type paramType = paramTypes[i];
- body.append(InstructionFactory.createLoad(paramType, pos));
-// if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals(unMangledInterMethod.getParameterTypes()[i].getErasureSignature())) {
-// System.err.println("Putting in cast from "+paramType+" to "+bridgingToParms[i]);
-// body.append(fact.createCast(paramType,bridgingToParms[i]));
-// }
- pos+=paramType.getSize();
+ Type paramType = paramTypes[i];
+ body.append(InstructionFactory.createLoad(paramType, pos));
+ // if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().
+ // equals
+ // (unMangledInterMethod.getParameterTypes()[i].getErasureSignature
+ // ())) {
+ // System.err.println("Putting in cast from "+paramType+" to "+
+ // bridgingToParms[i]);
+ // body.append(fact.createCast(paramType,bridgingToParms[i]));
+ // }
+ pos += paramType.getSize();
}
- body.append(Utility.createInvoke(fact, world,unMangledInterMethod));
+ body.append(Utility.createInvoke(fact, world, unMangledInterMethod));
body.append(InstructionFactory.createReturn(returnType));
clazz.addMethodGen(bridgeMethod);
}
-
+
// Unlike toString() on a member, this does not include the declaring type
private String stringifyMember(ResolvedMember member) {
StringBuffer buf = new StringBuffer();
- buf.append(member.getReturnType().getName());
- buf.append(' ');
- buf.append(member.getName());
- if (member.getKind() != Member.FIELD) {
- buf.append("(");
- UnresolvedType[] params = member.getParameterTypes();
- if (params.length != 0) {
- buf.append(params[0]);
- for (int i=1, len = params.length; i < len; i++) {
- buf.append(", ");
- buf.append(params[i].getName());
- }
- }
- buf.append(")");
- }
- return buf.toString();
+ buf.append(member.getReturnType().getName());
+ buf.append(' ');
+ buf.append(member.getName());
+ if (member.getKind() != Member.FIELD) {
+ buf.append("(");
+ UnresolvedType[] params = member.getParameterTypes();
+ if (params.length != 0) {
+ buf.append(params[0]);
+ for (int i = 1, len = params.length; i < len; i++) {
+ buf.append(", ");
+ buf.append(params[i].getName());
+ }
+ }
+ buf.append(")");
+ }
+ return buf.toString();
}
-
- private boolean mungeMethodDelegate(BcelClassWeaver weaver, MethodDelegateTypeMunger munger) {
- ResolvedMember introduced = munger.getSignature();
-
- LazyClassGen gen = weaver.getLazyClassGen();
-
- ResolvedType fromType = weaver.getWorld().resolve(introduced.getDeclaringType(),munger.getSourceLocation());
- if (fromType.isRawType()) fromType = fromType.getGenericType();
-
- if (gen.getType().isAnnotation() || gen.getType().isEnum()) {
- // don't signal error as it could be a consequence of a wild type pattern
- return false;
- }
-
- boolean shouldApply = munger.matches(weaver.getLazyClassGen().getType(), aspectType);
- if (shouldApply) {
-
- // If no implementation class was specified, the intention was that the types matching the pattern
- // already implemented the interface, let's check that now!
- if (munger.getImplClassName()==null) {
- boolean isOK = false;
- List/*LazyMethodGen*/ existingMethods = gen.getMethodGens();
- for (Iterator i = existingMethods.iterator(); i.hasNext() && !isOK;) {
- LazyMethodGen m = (LazyMethodGen) i.next();
- if (m.getName().equals(introduced.getName()) &&
- m.getParameterSignature().equals(introduced.getParameterSignature()) &&
- m.getReturnType().equals(introduced.getReturnType())) {
- isOK = true;
- }
- }
- if (!isOK) {
- // the class does not implement this method, they needed to supply a default impl class
- IMessage msg = new Message("@DeclareParents: No defaultImpl was specified but the type '"+gen.getName()+
- "' does not implement the method '"+stringifyMember(introduced)+"' defined on the interface '"+introduced.getDeclaringType()+"'",
- weaver.getLazyClassGen().getType().getSourceLocation(),true,new ISourceLocation[]{munger.getSourceLocation()});
- weaver.getWorld().getMessageHandler().handleMessage(msg);
- return false;
- }
-
- return true;
- }
-
-
-
- LazyMethodGen mg = new LazyMethodGen(
- introduced.getModifiers() - Modifier.ABSTRACT,
- BcelWorld.makeBcelType(introduced.getReturnType()),
- introduced.getName(),
- BcelWorld.makeBcelTypes(introduced.getParameterTypes()),
- BcelWorld.makeBcelTypesAsClassNames(introduced.getExceptions()),
- gen
- );
-
- //annotation copy from annotation on ITD interface
- if (weaver.getWorld().isInJava5Mode()){
- AnnotationX annotationsOnRealMember[] = null;
- ResolvedType toLookOn = weaver.getWorld().lookupOrCreateName(introduced.getDeclaringType());
- if (fromType.isRawType()) toLookOn = fromType.getGenericType();
- // lookup the method
- ResolvedMember[] ms = toLookOn.getDeclaredJavaMethods();
- for (int i = 0; i < ms.length; i++) {
- ResolvedMember m = ms[i];
- if (introduced.getName().equals(m.getName()) && introduced.getSignature().equals(m.getSignature())) {
- annotationsOnRealMember = m.getAnnotations();
- }
- }
- if (annotationsOnRealMember!=null) {
- for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
- mg.addAnnotation(new AnnotationX(ag,weaver.getWorld()));
- }
- }
- }
-
- InstructionList body = new InstructionList();
- InstructionFactory fact = gen.getFactory();
-
- // getfield
- body.append(InstructionConstants.ALOAD_0);
- body.append(Utility.createGet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
- InstructionBranch ifNonNull = InstructionFactory.createBranchInstruction(Constants.IFNONNULL, null);
- body.append(ifNonNull);
-
- // Create and store a new instance
- body.append(InstructionConstants.ALOAD_0);
- body.append(fact.createNew(munger.getImplClassName()));
- body.append(InstructionConstants.DUP);
- body.append(fact.createInvoke(munger.getImplClassName(), "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
- body.append(Utility.createSet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
-
- // if not null use the instance we've got
- InstructionHandle ifNonNullElse = body.append(InstructionConstants.ALOAD_0);
- ifNonNull.setTarget(ifNonNullElse);
- body.append(Utility.createGet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
-
- //args
- int pos = 0;
- if (!introduced.isStatic()) { // skip 'this' (?? can this really happen)
- //body.append(InstructionFactory.createThis());
- pos++;
- }
- Type[] paramTypes = BcelWorld.makeBcelTypes(introduced.getParameterTypes());
- for (int i = 0, len = paramTypes.length; i < len; i++) {
- Type paramType = paramTypes[i];
- body.append(InstructionFactory.createLoad(paramType, pos));
- pos+=paramType.getSize();
- }
- body.append(Utility.createInvoke(fact, Constants.INVOKEINTERFACE, introduced));
- body.append(
- InstructionFactory.createReturn(
- BcelWorld.makeBcelType(introduced.getReturnType())
- )
- );
-
- mg.getBody().append(body);
- weaver.addLazyMethodGen(mg);
- weaver.getLazyClassGen().warnOnAddedMethod(mg.getMethod(),getSignature().getSourceLocation());
- return true;
- }
- return false;
- }
-
- private boolean mungeFieldHost(BcelClassWeaver weaver, MethodDelegateTypeMunger.FieldHostTypeMunger munger) {
- LazyClassGen gen = weaver.getLazyClassGen();
- if (gen.getType().isAnnotation() || gen.getType().isEnum()) {
- // don't signal error as it could be a consequence of a wild type pattern
- return false;
- }
-// boolean shouldApply =
- munger.matches(weaver.getLazyClassGen().getType(), aspectType); // why do this?
- ResolvedMember host = AjcMemberMaker.itdAtDeclareParentsField(
- weaver.getLazyClassGen().getType(),
- munger.getSignature().getType(),
- aspectType);
- weaver.getLazyClassGen().addField(makeFieldGen(
- weaver.getLazyClassGen(),
- host), null);
- return true;
- }
-
-
- private ResolvedMember getRealMemberForITDFromAspect(ResolvedType aspectType,ResolvedMember lookingFor,boolean isCtorRelated) {
+
+ private boolean mungeMethodDelegate(BcelClassWeaver weaver, MethodDelegateTypeMunger munger) {
+ ResolvedMember introduced = munger.getSignature();
+
+ LazyClassGen gen = weaver.getLazyClassGen();
+
+ ResolvedType fromType = weaver.getWorld().resolve(introduced.getDeclaringType(), munger.getSourceLocation());
+ if (fromType.isRawType())
+ fromType = fromType.getGenericType();
+
+ if (gen.getType().isAnnotation() || gen.getType().isEnum()) {
+ // don't signal error as it could be a consequence of a wild type
+ // pattern
+ return false;
+ }
+
+ boolean shouldApply = munger.matches(weaver.getLazyClassGen().getType(), aspectType);
+ if (shouldApply) {
+
+ // If no implementation class was specified, the intention was that
+ // the types matching the pattern
+ // already implemented the interface, let's check that now!
+ if (munger.getImplClassName() == null) {
+ boolean isOK = false;
+ List/* LazyMethodGen */existingMethods = gen.getMethodGens();
+ for (Iterator i = existingMethods.iterator(); i.hasNext() && !isOK;) {
+ LazyMethodGen m = (LazyMethodGen) i.next();
+ if (m.getName().equals(introduced.getName())
+ && m.getParameterSignature().equals(introduced.getParameterSignature())
+ && m.getReturnType().equals(introduced.getReturnType())) {
+ isOK = true;
+ }
+ }
+ if (!isOK) {
+ // the class does not implement this method, they needed to
+ // supply a default impl class
+ IMessage msg = new Message("@DeclareParents: No defaultImpl was specified but the type '" + gen.getName()
+ + "' does not implement the method '" + stringifyMember(introduced) + "' defined on the interface '"
+ + introduced.getDeclaringType() + "'", weaver.getLazyClassGen().getType().getSourceLocation(), true,
+ new ISourceLocation[] { munger.getSourceLocation() });
+ weaver.getWorld().getMessageHandler().handleMessage(msg);
+ return false;
+ }
+
+ return true;
+ }
+
+ LazyMethodGen mg = new LazyMethodGen(introduced.getModifiers() - Modifier.ABSTRACT, BcelWorld.makeBcelType(introduced
+ .getReturnType()), introduced.getName(), BcelWorld.makeBcelTypes(introduced.getParameterTypes()), BcelWorld
+ .makeBcelTypesAsClassNames(introduced.getExceptions()), gen);
+
+ // annotation copy from annotation on ITD interface
+ if (weaver.getWorld().isInJava5Mode()) {
+ AnnotationAJ annotationsOnRealMember[] = null;
+ ResolvedType toLookOn = weaver.getWorld().lookupOrCreateName(introduced.getDeclaringType());
+ if (fromType.isRawType())
+ toLookOn = fromType.getGenericType();
+ // lookup the method
+ ResolvedMember[] ms = toLookOn.getDeclaredJavaMethods();
+ for (int i = 0; i < ms.length; i++) {
+ ResolvedMember m = ms[i];
+ if (introduced.getName().equals(m.getName()) && introduced.getSignature().equals(m.getSignature())) {
+ annotationsOnRealMember = m.getAnnotations();
+ }
+ }
+ if (annotationsOnRealMember != null) {
+ for (int i = 0; i < annotationsOnRealMember.length; i++) {
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
+ mg.addAnnotation(new BcelAnnotation(ag, weaver.getWorld()));
+ }
+ }
+ }
+
+ InstructionList body = new InstructionList();
+ InstructionFactory fact = gen.getFactory();
+
+ // getfield
+ body.append(InstructionConstants.ALOAD_0);
+ body.append(Utility.createGet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
+ InstructionBranch ifNonNull = InstructionFactory.createBranchInstruction(Constants.IFNONNULL, null);
+ body.append(ifNonNull);
+
+ // Create and store a new instance
+ body.append(InstructionConstants.ALOAD_0);
+ body.append(fact.createNew(munger.getImplClassName()));
+ body.append(InstructionConstants.DUP);
+ body.append(fact.createInvoke(munger.getImplClassName(), "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+ body.append(Utility.createSet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
+
+ // if not null use the instance we've got
+ InstructionHandle ifNonNullElse = body.append(InstructionConstants.ALOAD_0);
+ ifNonNull.setTarget(ifNonNullElse);
+ body.append(Utility.createGet(fact, munger.getDelegate(weaver.getLazyClassGen().getType())));
+
+ // args
+ int pos = 0;
+ if (!introduced.isStatic()) { // skip 'this' (?? can this really
+ // happen)
+ // body.append(InstructionFactory.createThis());
+ pos++;
+ }
+ Type[] paramTypes = BcelWorld.makeBcelTypes(introduced.getParameterTypes());
+ for (int i = 0, len = paramTypes.length; i < len; i++) {
+ Type paramType = paramTypes[i];
+ body.append(InstructionFactory.createLoad(paramType, pos));
+ pos += paramType.getSize();
+ }
+ body.append(Utility.createInvoke(fact, Constants.INVOKEINTERFACE, introduced));
+ body.append(InstructionFactory.createReturn(BcelWorld.makeBcelType(introduced.getReturnType())));
+
+ mg.getBody().append(body);
+ weaver.addLazyMethodGen(mg);
+ weaver.getLazyClassGen().warnOnAddedMethod(mg.getMethod(), getSignature().getSourceLocation());
+ return true;
+ }
+ return false;
+ }
+
+ private boolean mungeFieldHost(BcelClassWeaver weaver, MethodDelegateTypeMunger.FieldHostTypeMunger munger) {
+ LazyClassGen gen = weaver.getLazyClassGen();
+ if (gen.getType().isAnnotation() || gen.getType().isEnum()) {
+ // don't signal error as it could be a consequence of a wild type
+ // pattern
+ return false;
+ }
+ // boolean shouldApply =
+ munger.matches(weaver.getLazyClassGen().getType(), aspectType); // why
+ // do
+ // this?
+ ResolvedMember host = AjcMemberMaker.itdAtDeclareParentsField(weaver.getLazyClassGen().getType(), munger.getSignature()
+ .getType(), aspectType);
+ weaver.getLazyClassGen().addField(makeFieldGen(weaver.getLazyClassGen(), host), null);
+ return true;
+ }
+
+ private ResolvedMember getRealMemberForITDFromAspect(ResolvedType aspectType, ResolvedMember lookingFor, boolean isCtorRelated) {
World world = aspectType.getWorld();
boolean debug = false;
if (debug) {
- System.err.println("Searching for a member on type: "+aspectType);
- System.err.println("Member we are looking for: "+lookingFor);
+ System.err.println("Searching for a member on type: " + aspectType);
+ System.err.println("Member we are looking for: " + lookingFor);
}
ResolvedMember aspectMethods[] = aspectType.getDeclaredMethods();
- UnresolvedType [] lookingForParams = lookingFor.getParameterTypes();
-
+ UnresolvedType[] lookingForParams = lookingFor.getParameterTypes();
+
ResolvedMember realMember = null;
- for (int i = 0; realMember==null && i < aspectMethods.length; i++) {
+ for (int i = 0; realMember == null && i < aspectMethods.length; i++) {
ResolvedMember member = aspectMethods[i];
- if (member.getName().equals(lookingFor.getName())){
- UnresolvedType [] memberParams = member.getGenericParameterTypes();
- if (memberParams.length == lookingForParams.length){
- if (debug) System.err.println("Reviewing potential candidates: "+member);
+ if (member.getName().equals(lookingFor.getName())) {
+ UnresolvedType[] memberParams = member.getGenericParameterTypes();
+ if (memberParams.length == lookingForParams.length) {
+ if (debug)
+ System.err.println("Reviewing potential candidates: " + member);
boolean matchOK = true;
- // If not related to a ctor ITD then the name is enough to confirm we have the
- // right one. If it is ctor related we need to check the params all match, although
+ // If not related to a ctor ITD then the name is enough to
+ // confirm we have the
+ // right one. If it is ctor related we need to check the
+ // params all match, although
// only the erasure.
if (isCtorRelated) {
- for (int j = 0; j < memberParams.length && matchOK; j++){
- ResolvedType pMember = memberParams[j].resolve(world);
- ResolvedType pLookingFor = lookingForParams[j].resolve(world);
-
- if (pMember.isTypeVariableReference())
- pMember = ((TypeVariableReference)pMember).getTypeVariable().getFirstBound().resolve(world);
- if (pMember.isParameterizedType() || pMember.isGenericType())
- pMember = pMember.getRawType().resolve(aspectType.getWorld());
-
- if (pLookingFor.isTypeVariableReference())
- pLookingFor = ((TypeVariableReference)pLookingFor).getTypeVariable().getFirstBound().resolve(world);
- if (pLookingFor.isParameterizedType() || pLookingFor.isGenericType())
- pLookingFor = pLookingFor.getRawType().resolve(world);
-
- if (debug) System.err.println("Comparing parameter "+j+" member="+pMember+" lookingFor="+pLookingFor);
- if (!pMember.equals(pLookingFor)){
- matchOK=false;
+ for (int j = 0; j < memberParams.length && matchOK; j++) {
+ ResolvedType pMember = memberParams[j].resolve(world);
+ ResolvedType pLookingFor = lookingForParams[j].resolve(world);
+
+ if (pMember.isTypeVariableReference())
+ pMember = ((TypeVariableReference) pMember).getTypeVariable().getFirstBound().resolve(world);
+ if (pMember.isParameterizedType() || pMember.isGenericType())
+ pMember = pMember.getRawType().resolve(aspectType.getWorld());
+
+ if (pLookingFor.isTypeVariableReference())
+ pLookingFor = ((TypeVariableReference) pLookingFor).getTypeVariable().getFirstBound()
+ .resolve(world);
+ if (pLookingFor.isParameterizedType() || pLookingFor.isGenericType())
+ pLookingFor = pLookingFor.getRawType().resolve(world);
+
+ if (debug)
+ System.err.println("Comparing parameter " + j + " member=" + pMember + " lookingFor="
+ + pLookingFor);
+ if (!pMember.equals(pLookingFor)) {
+ matchOK = false;
+ }
}
- }
}
- if (matchOK) realMember = member;
+ if (matchOK)
+ realMember = member;
}
}
}
- if (debug && realMember==null) System.err.println("Didn't find a match");
+ if (debug && realMember == null)
+ System.err.println("Didn't find a match");
return realMember;
}
- private void addNeededSuperCallMethods(
- BcelClassWeaver weaver,
- ResolvedType onType,
- Set neededSuperCalls)
- {
+ private void addNeededSuperCallMethods(BcelClassWeaver weaver, ResolvedType onType, Set neededSuperCalls) {
LazyClassGen gen = weaver.getLazyClassGen();
-
+
for (Iterator iter = neededSuperCalls.iterator(); iter.hasNext();) {
ResolvedMember superMethod = (ResolvedMember) iter.next();
if (weaver.addDispatchTarget(superMethod)) {
- //System.err.println("super type: " + superMethod.getDeclaringType() + ", " + gen.getType());
+ // System.err.println("super type: " +
+ // superMethod.getDeclaringType() + ", " + gen.getType());
boolean isSuper = !superMethod.getDeclaringType().equals(gen.getType());
String dispatchName;
if (isSuper)
- dispatchName =
- NameMangler.superDispatchMethod(onType, superMethod.getName());
+ dispatchName = NameMangler.superDispatchMethod(onType, superMethod.getName());
else
- dispatchName =
- NameMangler.protectedDispatchMethod(
- onType,
- superMethod.getName());
+ dispatchName = NameMangler.protectedDispatchMethod(onType, superMethod.getName());
superMethod = superMethod.resolve(weaver.getWorld());
- LazyMethodGen dispatcher =
- makeDispatcher(
- gen,
- dispatchName,
- superMethod,
- weaver.getWorld(),
- isSuper);
+ LazyMethodGen dispatcher = makeDispatcher(gen, dispatchName, superMethod, weaver.getWorld(), isSuper);
weaver.addLazyMethodGen(dispatcher);
}
}
}
- private void signalError(String msgid,BcelClassWeaver weaver,UnresolvedType onType) {
- IMessage msg = MessageUtil.error(
- WeaverMessages.format(msgid,onType.getName()),getSourceLocation());
+ private void signalError(String msgid, BcelClassWeaver weaver, UnresolvedType onType) {
+ IMessage msg = MessageUtil.error(WeaverMessages.format(msgid, onType.getName()), getSourceLocation());
weaver.getWorld().getMessageHandler().handleMessage(msg);
}
- private boolean mungeNewConstructor(
- BcelClassWeaver weaver,
- NewConstructorTypeMunger newConstructorTypeMunger)
- {
-
+ private boolean mungeNewConstructor(BcelClassWeaver weaver, NewConstructorTypeMunger newConstructorTypeMunger) {
+
final LazyClassGen currentClass = weaver.getLazyClassGen();
final InstructionFactory fact = currentClass.getFactory();
ResolvedMember newConstructorMember = newConstructorTypeMunger.getSyntheticConstructor();
- ResolvedType onType = newConstructorMember.getDeclaringType().resolve(weaver.getWorld());
- if (onType.isRawType()) onType = onType.getGenericType();
-
+ ResolvedType onType = newConstructorMember.getDeclaringType().resolve(weaver.getWorld());
+ if (onType.isRawType())
+ onType = onType.getGenericType();
+
if (onType.isAnnotation()) {
- signalError(WeaverMessages.ITDC_ON_ANNOTATION_NOT_ALLOWED,weaver,onType);
+ signalError(WeaverMessages.ITDC_ON_ANNOTATION_NOT_ALLOWED, weaver, onType);
return false;
}
-
+
if (onType.isEnum()) {
- signalError(WeaverMessages.ITDC_ON_ENUM_NOT_ALLOWED,weaver,onType);
+ signalError(WeaverMessages.ITDC_ON_ENUM_NOT_ALLOWED, weaver, onType);
return false;
}
-
- if (! onType.equals(currentClass.getType())) return false;
+
+ if (!onType.equals(currentClass.getType()))
+ return false;
ResolvedMember explicitConstructor = newConstructorTypeMunger.getExplicitConstructor();
- //int declaredParameterCount = newConstructorTypeMunger.getDeclaredParameterCount();
- LazyMethodGen mg =
- makeMethodGen(currentClass, newConstructorMember);
- mg.setEffectiveSignature(newConstructorTypeMunger.getSignature(),Shadow.ConstructorExecution,true);
-
-// pr98901
- // For copying the annotations across, we have to discover the real member in the aspect
- // which is holding them.
- if (weaver.getWorld().isInJava5Mode()){
-
- ResolvedMember interMethodDispatcher =AjcMemberMaker.postIntroducedConstructor(aspectType,onType,newConstructorTypeMunger.getSignature().getParameterTypes());
- AnnotationX annotationsOnRealMember[] = null;
- ResolvedMember realMember = getRealMemberForITDFromAspect(aspectType,interMethodDispatcher,true);
- if (realMember==null) throw new BCException("Couldn't find ITD holder member '"+
- interMethodDispatcher+"' on aspect "+aspectType);
+ // int declaredParameterCount =
+ // newConstructorTypeMunger.getDeclaredParameterCount();
+ LazyMethodGen mg = makeMethodGen(currentClass, newConstructorMember);
+ mg.setEffectiveSignature(newConstructorTypeMunger.getSignature(), Shadow.ConstructorExecution, true);
+
+ // pr98901
+ // For copying the annotations across, we have to discover the real
+ // member in the aspect
+ // which is holding them.
+ if (weaver.getWorld().isInJava5Mode()) {
+
+ ResolvedMember interMethodDispatcher = AjcMemberMaker.postIntroducedConstructor(aspectType, onType,
+ newConstructorTypeMunger.getSignature().getParameterTypes());
+ AnnotationAJ annotationsOnRealMember[] = null;
+ ResolvedMember realMember = getRealMemberForITDFromAspect(aspectType, interMethodDispatcher, true);
+ if (realMember == null)
+ throw new BCException("Couldn't find ITD holder member '" + interMethodDispatcher + "' on aspect " + aspectType);
annotationsOnRealMember = realMember.getAnnotations();
- if (annotationsOnRealMember!=null) {
+ if (annotationsOnRealMember != null) {
for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
- mg.addAnnotation(new AnnotationX(ag,weaver.getWorld()));
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
+ mg.addAnnotation(new BcelAnnotation(ag, weaver.getWorld()));
}
}
// the below loop fixes the very special (and very stupid)
// case where an aspect declares an annotation
// on an ITD it declared on itself.
List allDecams = weaver.getWorld().getDeclareAnnotationOnMethods();
- for (Iterator i = allDecams.iterator(); i.hasNext();){
- DeclareAnnotation decaMC = (DeclareAnnotation) i.next();
- if (decaMC.matches(explicitConstructor,weaver.getWorld())
- && mg.getEnclosingClass().getType() == aspectType) {
+ for (Iterator i = allDecams.iterator(); i.hasNext();) {
+ DeclareAnnotation decaMC = (DeclareAnnotation) i.next();
+ if (decaMC.matches(explicitConstructor, weaver.getWorld()) && mg.getEnclosingClass().getType() == aspectType) {
mg.addAnnotation(decaMC.getAnnotationX());
}
}
}
-
+
currentClass.addMethodGen(mg);
- //weaver.addLazyMethodGen(freshConstructor);
-
+ // weaver.addLazyMethodGen(freshConstructor);
+
InstructionList body = mg.getBody();
-
- // add to body: push arts for call to pre, from actual args starting at 1 (skipping this), going to
- // declared argcount + 1
+
+ // add to body: push arts for call to pre, from actual args starting at
+ // 1 (skipping this), going to
+ // declared argcount + 1
UnresolvedType[] declaredParams = newConstructorTypeMunger.getSignature().getParameterTypes();
Type[] paramTypes = mg.getArgumentTypes();
int frameIndex = 1;
frameIndex += paramTypes[i].getSize();
}
// do call to pre
- Member preMethod =
- AjcMemberMaker.preIntroducedConstructor(aspectType, onType, declaredParams);
+ Member preMethod = AjcMemberMaker.preIntroducedConstructor(aspectType, onType, declaredParams);
body.append(Utility.createInvoke(fact, null, preMethod));
-
+
// create a local, and store return pre stuff into it.
int arraySlot = mg.allocateLocal(1);
body.append(InstructionFactory.createStore(Type.OBJECT, arraySlot));
-
+
// put this on the stack
body.append(InstructionConstants.ALOAD_0);
-
+
// unpack pre args onto stack
UnresolvedType[] superParamTypes = explicitConstructor.getParameterTypes();
-
+
for (int i = 0, len = superParamTypes.length; i < len; i++) {
body.append(InstructionFactory.createLoad(Type.OBJECT, arraySlot));
body.append(Utility.createConstant(fact, i));
body.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- body.append(
- Utility.createConversion(
- fact,
- Type.OBJECT,
- BcelWorld.makeBcelType(superParamTypes[i])));
+ body.append(Utility.createConversion(fact, Type.OBJECT, BcelWorld.makeBcelType(superParamTypes[i])));
}
// call super/this
-
+
body.append(Utility.createInvoke(fact, null, explicitConstructor));
-
+
// put this back on the stack
body.append(InstructionConstants.ALOAD_0);
-
+
// unpack params onto stack
- Member postMethod =
- AjcMemberMaker.postIntroducedConstructor(aspectType, onType, declaredParams);
+ Member postMethod = AjcMemberMaker.postIntroducedConstructor(aspectType, onType, declaredParams);
UnresolvedType[] postParamTypes = postMethod.getParameterTypes();
-
+
for (int i = 1, len = postParamTypes.length; i < len; i++) {
body.append(InstructionFactory.createLoad(Type.OBJECT, arraySlot));
- body.append(Utility.createConstant(fact, superParamTypes.length + i-1));
+ body.append(Utility.createConstant(fact, superParamTypes.length + i - 1));
body.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- body.append(
- Utility.createConversion(
- fact,
- Type.OBJECT,
- BcelWorld.makeBcelType(postParamTypes[i])));
- }
-
+ body.append(Utility.createConversion(fact, Type.OBJECT, BcelWorld.makeBcelType(postParamTypes[i])));
+ }
+
// call post
body.append(Utility.createInvoke(fact, null, postMethod));
-
+
// don't forget to return!!
body.append(InstructionConstants.RETURN);
-
- return true;
- }
+ return true;
+ }
- private static LazyMethodGen makeDispatcher(
- LazyClassGen onGen,
- String dispatchName,
- ResolvedMember superMethod,
- BcelWorld world,
- boolean isSuper)
- {
+ private static LazyMethodGen makeDispatcher(LazyClassGen onGen, String dispatchName, ResolvedMember superMethod,
+ BcelWorld world, boolean isSuper) {
Type[] paramTypes = BcelWorld.makeBcelTypes(superMethod.getParameterTypes());
Type returnType = BcelWorld.makeBcelType(superMethod.getReturnType());
-
+
int modifiers = Modifier.PUBLIC;
- if (onGen.isInterface()) modifiers |= Modifier.ABSTRACT;
-
- LazyMethodGen mg =
- new LazyMethodGen(
- modifiers,
- returnType,
- dispatchName,
- paramTypes,
- UnresolvedType.getNames(superMethod.getExceptions()),
- onGen);
+ if (onGen.isInterface())
+ modifiers |= Modifier.ABSTRACT;
+
+ LazyMethodGen mg = new LazyMethodGen(modifiers, returnType, dispatchName, paramTypes, UnresolvedType.getNames(superMethod
+ .getExceptions()), onGen);
InstructionList body = mg.getBody();
-
- if (onGen.isInterface()) return mg;
-
+
+ if (onGen.isInterface())
+ return mg;
+
// assert (!superMethod.isStatic())
InstructionFactory fact = onGen.getFactory();
int pos = 0;
-
+
body.append(InstructionFactory.createThis());
pos++;
for (int i = 0, len = paramTypes.length; i < len; i++) {
Type paramType = paramTypes[i];
body.append(InstructionFactory.createLoad(paramType, pos));
- pos+=paramType.getSize();
+ pos += paramType.getSize();
}
if (isSuper) {
body.append(Utility.createSuperInvoke(fact, world, superMethod));
body.append(InstructionFactory.createReturn(returnType));
return mg;
- }
-
+ }
+
private boolean mungeNewField(BcelClassWeaver weaver, NewFieldTypeMunger munger) {
- /*ResolvedMember initMethod = */munger.getInitMethod(aspectType);
+ /* ResolvedMember initMethod = */munger.getInitMethod(aspectType);
LazyClassGen gen = weaver.getLazyClassGen();
ResolvedMember field = munger.getSignature();
-
- ResolvedType onType = weaver.getWorld().resolve(field.getDeclaringType(),munger.getSourceLocation());
- if (onType.isRawType()) onType = onType.getGenericType();
+
+ ResolvedType onType = weaver.getWorld().resolve(field.getDeclaringType(), munger.getSourceLocation());
+ if (onType.isRawType())
+ onType = onType.getGenericType();
boolean onInterface = onType.isInterface();
-
+
if (onType.isAnnotation()) {
- signalError(WeaverMessages.ITDF_ON_ANNOTATION_NOT_ALLOWED,weaver,onType);
+ signalError(WeaverMessages.ITDF_ON_ANNOTATION_NOT_ALLOWED, weaver, onType);
return false;
}
-
+
if (onType.isEnum()) {
- signalError(WeaverMessages.ITDF_ON_ENUM_NOT_ALLOWED,weaver,onType);
+ signalError(WeaverMessages.ITDF_ON_ENUM_NOT_ALLOWED, weaver, onType);
return false;
}
-
+
ResolvedMember interMethodBody = munger.getInitMethod(aspectType);
-
- AnnotationX annotationsOnRealMember[] = null;
+
+ AnnotationAJ annotationsOnRealMember[] = null;
// pr98901
- // For copying the annotations across, we have to discover the real member in the aspect
- // which is holding them.
- if (weaver.getWorld().isInJava5Mode()){
- // the below line just gets the method with the same name in aspectType.getDeclaredMethods();
- ResolvedType toLookOn = aspectType;
- if (aspectType.isRawType()) toLookOn = aspectType.getGenericType();
- ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn,interMethodBody,false);
- if (realMember==null) throw new BCException("Couldn't find ITD init member '"+
- interMethodBody+"' on aspect "+aspectType);
- annotationsOnRealMember = realMember.getAnnotations();
+ // For copying the annotations across, we have to discover the real
+ // member in the aspect
+ // which is holding them.
+ if (weaver.getWorld().isInJava5Mode()) {
+ // the below line just gets the method with the same name in
+ // aspectType.getDeclaredMethods();
+ ResolvedType toLookOn = aspectType;
+ if (aspectType.isRawType())
+ toLookOn = aspectType.getGenericType();
+ ResolvedMember realMember = getRealMemberForITDFromAspect(toLookOn, interMethodBody, false);
+ if (realMember == null)
+ throw new BCException("Couldn't find ITD init member '" + interMethodBody + "' on aspect " + aspectType);
+ annotationsOnRealMember = realMember.getAnnotations();
}
-
+
if (onType.equals(gen.getType())) {
if (onInterface) {
ResolvedMember itdfieldGetter = AjcMemberMaker.interFieldInterfaceGetter(field, onType, aspectType);
LazyMethodGen mg = makeMethodGen(gen, itdfieldGetter);
gen.addMethodGen(mg);
-
- LazyMethodGen mg1 = makeMethodGen(gen,
- AjcMemberMaker.interFieldInterfaceSetter(field, onType, aspectType));
+
+ LazyMethodGen mg1 = makeMethodGen(gen, AjcMemberMaker.interFieldInterfaceSetter(field, onType, aspectType));
gen.addMethodGen(mg1);
} else {
weaver.addInitializer(this);
- FieldGen fg = makeFieldGen(gen,
- AjcMemberMaker.interFieldClassField(field, aspectType));
-
- if (annotationsOnRealMember!=null) {
+ FieldGen fg = makeFieldGen(gen, AjcMemberMaker.interFieldClassField(field, aspectType));
+
+ if (annotationsOnRealMember != null) {
for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
fg.addAnnotation(ag);
}
}
-
-
- if (weaver.getWorld().isInJava5Mode()){
+ if (weaver.getWorld().isInJava5Mode()) {
String basicSignature = field.getSignature();
String genericSignature = field.getReturnType().resolve(weaver.getWorld()).getSignatureForAttribute();
- // String genericSignature = ((ResolvedMemberImpl)field).getSignatureForAttribute();
+ // String genericSignature =
+ // ((ResolvedMemberImpl)field).getSignatureForAttribute();
if (!basicSignature.equals(genericSignature)) {
- // Add a signature attribute to it
- fg.addAttribute(createSignatureAttribute(gen.getConstantPool(),genericSignature));
+ // Add a signature attribute to it
+ fg.addAttribute(createSignatureAttribute(gen.getConstantPool(), genericSignature));
}
}
- gen.addField(fg,getSourceLocation());
-
+ gen.addField(fg, getSourceLocation());
+
}
- return true;
+ return true;
} else if (onInterface && gen.getType().isTopmostImplementor(onType)) {
- // wew know that we can't be static since we don't allow statics on interfaces
- if (field.isStatic()) throw new RuntimeException("unimplemented");
+ // wew know that we can't be static since we don't allow statics on
+ // interfaces
+ if (field.isStatic())
+ throw new RuntimeException("unimplemented");
weaver.addInitializer(this);
- //System.err.println("impl body on " + gen.getType() + " for " + munger);
-
-
- Type fieldType = BcelWorld.makeBcelType(field.getType());
-
- FieldGen fg = makeFieldGen(gen,AjcMemberMaker.interFieldInterfaceField(field, onType, aspectType));
-
- if (annotationsOnRealMember!=null) {
- for (int i = 0; i < annotationsOnRealMember.length; i++) {
- AnnotationX annotationX = annotationsOnRealMember[i];
- AnnotationGen a = annotationX.getBcelAnnotation();
- AnnotationGen ag = new AnnotationGen(a,weaver.getLazyClassGen().getConstantPool(),true);
- fg.addAnnotation(ag);
- }
+ // System.err.println("impl body on " + gen.getType() + " for " +
+ // munger);
+
+ Type fieldType = BcelWorld.makeBcelType(field.getType());
+
+ FieldGen fg = makeFieldGen(gen, AjcMemberMaker.interFieldInterfaceField(field, onType, aspectType));
+
+ if (annotationsOnRealMember != null) {
+ for (int i = 0; i < annotationsOnRealMember.length; i++) {
+ AnnotationAJ annotationX = annotationsOnRealMember[i];
+ AnnotationGen a = ((BcelAnnotation) annotationX).getBcelAnnotation();
+ AnnotationGen ag = new AnnotationGen(a, weaver.getLazyClassGen().getConstantPool(), true);
+ fg.addAnnotation(ag);
}
-
- gen.addField(fg,getSourceLocation());
- //this uses a shadow munger to add init method to constructors
- //weaver.getShadowMungers().add(makeInitCallShadowMunger(initMethod));
-
- ResolvedMember itdfieldGetter = AjcMemberMaker.interFieldInterfaceGetter(field, gen.getType()/*onType*/, aspectType);
+ }
+
+ gen.addField(fg, getSourceLocation());
+ // this uses a shadow munger to add init method to constructors
+ // weaver.getShadowMungers().add(makeInitCallShadowMunger(initMethod)
+ // );
+
+ ResolvedMember itdfieldGetter = AjcMemberMaker.interFieldInterfaceGetter(field, gen.getType()/* onType */, aspectType);
LazyMethodGen mg = makeMethodGen(gen, itdfieldGetter);
InstructionList il = new InstructionList();
InstructionFactory fact = gen.getFactory();
if (field.isStatic()) {
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.GETSTATIC));
+ il.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.GETSTATIC));
} else {
il.append(InstructionConstants.ALOAD_0);
- il.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.GETFIELD));
+ il.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.GETFIELD));
}
il.append(InstructionFactory.createReturn(fieldType));
mg.getBody().insert(il);
-
+
gen.addMethodGen(mg);
-
+
// Check if we need bridge methods for the field getter and setter
- if (munger.getDeclaredSignature()!=null) { // is this munger a parameterized form of some original munger?
- ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,munger.getSignature().getDeclaringType().resolve(getWorld()),false,munger.getTypeVariableAliases());
+ if (munger.getDeclaredSignature() != null) { // is this munger a
+ // parameterized
+ // form of some
+ // original munger?
+ ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,
+ munger.getSignature().getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases());
boolean needsbridging = false;
- if (!toBridgeTo.getReturnType().getErasureSignature().equals(munger.getSignature().getReturnType().getErasureSignature())) needsbridging = true;
+ if (!toBridgeTo.getReturnType().getErasureSignature().equals(
+ munger.getSignature().getReturnType().getErasureSignature()))
+ needsbridging = true;
if (needsbridging) {
- ResolvedMember bridgingGetter = AjcMemberMaker.interFieldInterfaceGetter(toBridgeTo, gen.getType(), aspectType);
- createBridgeMethodForITDF(weaver,gen,itdfieldGetter,bridgingGetter);
- }
- }
-
+ ResolvedMember bridgingGetter = AjcMemberMaker.interFieldInterfaceGetter(toBridgeTo, gen.getType(), aspectType);
+ createBridgeMethodForITDF(weaver, gen, itdfieldGetter, bridgingGetter);
+ }
+ }
+
ResolvedMember itdfieldSetter = AjcMemberMaker.interFieldInterfaceSetter(field, gen.getType(), aspectType);
LazyMethodGen mg1 = makeMethodGen(gen, itdfieldSetter);
InstructionList il1 = new InstructionList();
if (field.isStatic()) {
il1.append(InstructionFactory.createLoad(fieldType, 0));
- il1.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.PUTSTATIC));
+ il1.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.PUTSTATIC));
} else {
il1.append(InstructionConstants.ALOAD_0);
il1.append(InstructionFactory.createLoad(fieldType, 1));
- il1.append(fact.createFieldAccess(
- gen.getClassName(),
- fg.getName(),
- fieldType, Constants.PUTFIELD));
+ il1.append(fact.createFieldAccess(gen.getClassName(), fg.getName(), fieldType, Constants.PUTFIELD));
}
il1.append(InstructionFactory.createReturn(Type.VOID));
mg1.getBody().insert(il1);
-
+
gen.addMethodGen(mg1);
-
- if (munger.getDeclaredSignature()!=null) {
- ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,munger.getSignature().getDeclaringType().resolve(getWorld()),false,munger.getTypeVariableAliases());
- boolean needsbridging = false;
- if (!toBridgeTo.getReturnType().getErasureSignature().equals(munger.getSignature().getReturnType().getErasureSignature())) {
- needsbridging = true;
- }
- if (needsbridging) {
- ResolvedMember bridgingSetter = AjcMemberMaker.interFieldInterfaceSetter(toBridgeTo, gen.getType(), aspectType);
- createBridgeMethodForITDF(weaver, gen, itdfieldSetter, bridgingSetter);
- }
- }
-
- return true;
+
+ if (munger.getDeclaredSignature() != null) {
+ ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null,
+ munger.getSignature().getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases());
+ boolean needsbridging = false;
+ if (!toBridgeTo.getReturnType().getErasureSignature().equals(
+ munger.getSignature().getReturnType().getErasureSignature())) {
+ needsbridging = true;
+ }
+ if (needsbridging) {
+ ResolvedMember bridgingSetter = AjcMemberMaker.interFieldInterfaceSetter(toBridgeTo, gen.getType(), aspectType);
+ createBridgeMethodForITDF(weaver, gen, itdfieldSetter, bridgingSetter);
+ }
+ }
+
+ return true;
} else {
return false;
}
}
- // FIXME asc combine with other createBridge.. method in this class, avoid the duplication...
- private void createBridgeMethodForITDF(BcelClassWeaver weaver, LazyClassGen gen, ResolvedMember itdfieldSetter, ResolvedMember bridgingSetter) {
+ // FIXME asc combine with other createBridge.. method in this class, avoid
+ // the duplication...
+ private void createBridgeMethodForITDF(BcelClassWeaver weaver, LazyClassGen gen, ResolvedMember itdfieldSetter,
+ ResolvedMember bridgingSetter) {
InstructionFactory fact;
- LazyMethodGen bridgeMethod = makeMethodGen(gen,bridgingSetter);
+ LazyMethodGen bridgeMethod = makeMethodGen(gen, bridgingSetter);
Type[] paramTypes = BcelWorld.makeBcelTypes(bridgingSetter.getParameterTypes());
- Type[] bridgingToParms = BcelWorld.makeBcelTypes(itdfieldSetter.getParameterTypes());
- Type returnType = BcelWorld.makeBcelType(bridgingSetter.getReturnType());
- InstructionList body = bridgeMethod.getBody();
- fact = gen.getFactory();
- int pos = 0;
+ Type[] bridgingToParms = BcelWorld.makeBcelTypes(itdfieldSetter.getParameterTypes());
+ Type returnType = BcelWorld.makeBcelType(bridgingSetter.getReturnType());
+ InstructionList body = bridgeMethod.getBody();
+ fact = gen.getFactory();
+ int pos = 0;
- if (!bridgingSetter.isStatic()) {
+ if (!bridgingSetter.isStatic()) {
body.append(InstructionFactory.createThis());
pos++;
- }
- for (int i = 0, len = paramTypes.length; i < len; i++) {
+ }
+ for (int i = 0, len = paramTypes.length; i < len; i++) {
Type paramType = paramTypes[i];
body.append(InstructionFactory.createLoad(paramType, pos));
- if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals(itdfieldSetter.getParameterTypes()[i].getErasureSignature()) ) {
+ if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals(
+ itdfieldSetter.getParameterTypes()[i].getErasureSignature())) {
// une cast est required
- System.err.println("Putting in cast from "+paramType+" to "+bridgingToParms[i]);
- body.append(fact.createCast(paramType,bridgingToParms[i]));
+ System.err.println("Putting in cast from " + paramType + " to " + bridgingToParms[i]);
+ body.append(fact.createCast(paramType, bridgingToParms[i]));
}
- pos+=paramType.getSize();
- }
-
- body.append(Utility.createInvoke(fact, weaver.getWorld(), itdfieldSetter));
- body.append(InstructionFactory.createReturn(returnType));
- gen.addMethodGen(bridgeMethod);
+ pos += paramType.getSize();
+ }
+
+ body.append(Utility.createInvoke(fact, weaver.getWorld(), itdfieldSetter));
+ body.append(InstructionFactory.createReturn(returnType));
+ gen.addMethodGen(bridgeMethod);
}
-
+
public ConcreteTypeMunger parameterizedFor(ResolvedType target) {
- return new BcelTypeMunger(munger.parameterizedFor(target),aspectType);
+ return new BcelTypeMunger(munger.parameterizedFor(target), aspectType);
}
-
+
public ConcreteTypeMunger parameterizeWith(Map m, World w) {
- return new BcelTypeMunger(munger.parameterizeWith(m,w),aspectType);
+ return new BcelTypeMunger(munger.parameterizeWith(m, w), aspectType);
}
-
+
/**
- * Returns a list of type variable aliases used in this munger. For example, if the
- * ITD is 'int I<A,B>.m(List<A> las,List<B> lbs) {}' then this returns a list containing
- * the strings "A" and "B".
+ * Returns a list of type variable aliases used in this munger. For example, if the ITD is 'int I<A,B>.m(List<A> las,List<B>
+ * lbs) {}' then this returns a list containing the strings "A" and "B".
*/
- public List /*String*/ getTypeVariableAliases() {
+ public List /* String */getTypeVariableAliases() {
return munger.getTypeVariableAliases();
}
-
+
public boolean equals(Object other) {
- if (! (other instanceof BcelTypeMunger)) return false;
- BcelTypeMunger o = (BcelTypeMunger) other;
- return ((o.getMunger() == null) ? (getMunger() == null) : o.getMunger().equals(getMunger()))
- && ((o.getAspectType() == null) ? (getAspectType() == null) : o.getAspectType().equals(getAspectType()))
- && (AsmManager.getDefault().getHandleProvider().dependsOnLocation()
- ?((o.getSourceLocation()==null)? (getSourceLocation()==null): o.getSourceLocation().equals(getSourceLocation())):true); // pr134471 - remove when handles are improved to be independent of location
-
- }
-
- private volatile int hashCode = 0;
- public int hashCode() {
- if (hashCode == 0) {
- int result = 17;
- result = 37*result + ((getMunger() == null) ? 0 : getMunger().hashCode());
- result = 37*result + ((getAspectType() == null) ? 0 : getAspectType().hashCode());
- hashCode = result;
- }
- return hashCode;
- }
-
-
+ if (!(other instanceof BcelTypeMunger))
+ return false;
+ BcelTypeMunger o = (BcelTypeMunger) other;
+ return ((o.getMunger() == null) ? (getMunger() == null) : o.getMunger().equals(getMunger()))
+ && ((o.getAspectType() == null) ? (getAspectType() == null) : o.getAspectType().equals(getAspectType()))
+ && (AsmManager.getDefault().getHandleProvider().dependsOnLocation() ? ((o.getSourceLocation() == null) ? (getSourceLocation() == null)
+ : o.getSourceLocation().equals(getSourceLocation()))
+ : true); // pr134471 - remove when handles are improved
+ // to be independent of location
+
+ }
+
+ private volatile int hashCode = 0;
+
+ public int hashCode() {
+ if (hashCode == 0) {
+ int result = 17;
+ result = 37 * result + ((getMunger() == null) ? 0 : getMunger().hashCode());
+ result = 37 * result + ((getAspectType() == null) ? 0 : getAspectType().hashCode());
+ hashCode = result;
+ }
+ return hashCode;
+ }
+
/**
- * Some type mungers are created purely to help with the implementation of shadow mungers.
- * For example to support the cflow() pointcut we create a new cflow field in the aspect, and
- * that is added via a BcelCflowCounterFieldAdder.
+ * Some type mungers are created purely to help with the implementation of shadow mungers. For example to support the cflow()
+ * pointcut we create a new cflow field in the aspect, and that is added via a BcelCflowCounterFieldAdder.
*
- * During compilation we need to compare sets of type mungers, and if some only come into
- * existence after the 'shadowy' type things have been processed, we need to ignore
- * them during the comparison.
+ * During compilation we need to compare sets of type mungers, and if some only come into existence after the 'shadowy' type
+ * things have been processed, we need to ignore them during the comparison.
*
- * Returning true from this method indicates the type munger exists to support 'shadowy' stuff -
- * and so can be ignored in some comparison.
+ * Returning true from this method indicates the type munger exists to support 'shadowy' stuff - and so can be ignored in some
+ * comparison.
*/
public boolean existsToSupportShadowMunging() {
if (munger != null) {
return munger.existsToSupportShadowMunging();
}
- return false;
+ return false;
}
}
-
\ No newline at end of file
import org.aspectj.util.FileUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.Advice;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationOnTypeMunger;
-import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.AsmRelationshipProvider;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ConcreteTypeMunger;
private boolean inReweavableMode = false;
- private static Trace trace = TraceFactory.getTraceFactory().getTrace(BcelWeaver.class);
+ private static Trace trace = TraceFactory.getTraceFactory().getTrace(
+ BcelWeaver.class);
public BcelWeaver(BcelWorld world) {
super();
}
// ---- fields
- // private Map sourceJavaClasses = new HashMap(); /* String -> UnwovenClassFile */
+ // private Map sourceJavaClasses = new HashMap(); /* String ->
+ // UnwovenClassFile */
private List addedClasses = new ArrayList(); /* List<UnwovenClassFile> */
private List deletedTypenames = new ArrayList(); /* List<String> */
// private Map resources = new HashMap(); /* String -> UnwovenClassFile */
}
/**
- * Add the given aspect to the weaver. The type is resolved to support DOT for static inner classes as well as DOLLAR
+ * Add the given aspect to the weaver. The type is resolved to support DOT
+ * for static inner classes as well as DOLLAR
*
* @param aspectName
* @return aspect
String fixedName = aspectName;
int hasDot = fixedName.lastIndexOf('.');
while (hasDot > 0) {
- // System.out.println("BcelWeaver.addLibraryAspect " + fixedName);
+ // System.out.println("BcelWeaver.addLibraryAspect " +
+ // fixedName);
char[] fixedNameChars = fixedName.toCharArray();
fixedNameChars[hasDot] = '$';
fixedName = new String(fixedNameChars);
if (wsi != null && wsi.isReweavable()) {
BcelObjectType classType = getClassType(type.getName());
JavaClass wovenJavaClass = classType.getJavaClass();
- JavaClass unwovenJavaClass = Utility.makeJavaClass(wovenJavaClass.getFileName(), wsi
- .getUnwovenClassFileData(wovenJavaClass.getBytes()));
+ JavaClass unwovenJavaClass = Utility.makeJavaClass(
+ wovenJavaClass.getFileName(), wsi
+ .getUnwovenClassFileData(wovenJavaClass
+ .getBytes()));
world.storeClass(unwovenJavaClass);
classType.setJavaClass(unwovenJavaClass);
- // classType.setJavaClass(Utility.makeJavaClass(classType.getJavaClass().getFileName(),
- // wsi.getUnwovenClassFileData(classType.getJavaClass().getBytes())));
+ // classType.setJavaClass(Utility.makeJavaClass(classType.
+ // getJavaClass().getFileName(),
+ //wsi.getUnwovenClassFileData(classType.getJavaClass().getBytes(
+ // ))));
}
- // TODO AV - happens to reach that a lot of time: for each type flagged reweavable X for each aspect in the weaverstate
- // => mainly for nothing for LTW - pbly for something in incremental build...
+ // TODO AV - happens to reach that a lot of time: for each type
+ // flagged reweavable X for each aspect in the weaverstate
+ // => mainly for nothing for LTW - pbly for something in incremental
+ // build...
xcutSet.addOrReplaceAspect(type);
if (trace.isTraceEnabled())
trace.exit("addLibraryAspect", type);
if (type.getSuperclass().isAspect()) {
- // If the supertype includes ITDs and the user has not included that aspect in the aop.xml, they will
- // not get picked up, which can give unusual behaviour! See bug 223094
- // This change causes us to pick up the super aspect regardless of what was said in the aop.xml - giving
- // predictable behaviour. If the user also supplied it, there will be no problem other than the second
+ // If the supertype includes ITDs and the user has not included
+ // that aspect in the aop.xml, they will
+ // not get picked up, which can give unusual behaviour! See bug
+ // 223094
+ // This change causes us to pick up the super aspect regardless
+ // of what was said in the aop.xml - giving
+ // predictable behaviour. If the user also supplied it, there
+ // will be no problem other than the second
// addition overriding the first
addLibraryAspect(type.getSuperclass().getName());
}
return type;
} else {
// FIXME AV - better warning upon no such aspect from aop.xml
- RuntimeException ex = new RuntimeException("Cannot register non aspect: " + type.getName() + " , " + aspectName);
+ RuntimeException ex = new RuntimeException(
+ "Cannot register non aspect: " + type.getName() + " , "
+ + aspectName);
if (trace.isTraceEnabled())
trace.exit("addLibraryAspect", ex);
throw ex;
/**
*
- * @param inFile File path to class directory or zip/jar class archive
+ * @param inFile
+ * File path to class directory or zip/jar class archive
* @throws IOException
*/
public void addLibraryJarFile(File inFile) throws IOException {
}
}
- private List addAspectsFromJarFile(File inFile) throws FileNotFoundException, IOException {
- ZipInputStream inStream = new ZipInputStream(new FileInputStream(inFile)); // ??? buffered
+ private List addAspectsFromJarFile(File inFile)
+ throws FileNotFoundException, IOException {
+ ZipInputStream inStream = new ZipInputStream(
+ new FileInputStream(inFile)); // ??? buffered
List addedAspects = new ArrayList();
while (true) {
ZipEntry entry = inStream.getNextEntry();
}
// FIXME ASC performance? of this alternative soln.
- ClassParser parser = new ClassParser(new ByteArrayInputStream(FileUtil.readAsByteArray(inStream)), entry.getName());
+ ClassParser parser = new ClassParser(new ByteArrayInputStream(
+ FileUtil.readAsByteArray(inStream)), entry.getName());
JavaClass jc = parser.parse();
inStream.closeEntry();
- ResolvedType type = world.addSourceObjectType(jc).getResolvedTypeX();
+ ResolvedType type = world.addSourceObjectType(jc)
+ .getResolvedTypeX();
type.setBinaryPath(inFile.getAbsolutePath());
if (type.isAspect()) {
addedAspects.add(type);
return addedAspects;
}
- private List addAspectsFromDirectory(File dir) throws FileNotFoundException, IOException {
+ private List addAspectsFromDirectory(File dir)
+ throws FileNotFoundException, IOException {
List addedAspects = new ArrayList();
File[] classFiles = FileUtil.listFiles(dir, new FileFilter() {
for (int i = 0; i < classFiles.length; i++) {
FileInputStream fis = new FileInputStream(classFiles[i]);
byte[] bytes = FileUtil.readAsByteArray(fis);
- addIfAspect(bytes, classFiles[i].getAbsolutePath(), addedAspects, dir);
+ addIfAspect(bytes, classFiles[i].getAbsolutePath(), addedAspects,
+ dir);
fis.close();
}
return addedAspects;
}
- private void addIfAspect(byte[] bytes, String name, List toList, File dir) throws IOException {
- ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), name);
+ private void addIfAspect(byte[] bytes, String name, List toList, File dir)
+ throws IOException {
+ ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes),
+ name);
JavaClass jc = parser.parse();
ResolvedType type = world.addSourceObjectType(jc).getResolvedTypeX();
String typeName = type.getName().replace('.', File.separatorChar);
int end = name.lastIndexOf(typeName + ".class");
String binaryPath = null;
- // if end is -1 then something wierd happened, the class file is not in the correct place, something like
+ // if end is -1 then something wierd happened, the class file is not in
+ // the correct place, something like
// bin/A.class when the declaration for A specifies it is in a package.
if (end == -1) {
binaryPath = dir.getAbsolutePath();
}
// // The ANT copy task should be used to copy resources across.
- // private final static boolean CopyResourcesFromInpathDirectoriesToOutput=false;
+ // private final static boolean
+ // CopyResourcesFromInpathDirectoriesToOutput=false;
/**
- * Add any .class files in the directory to the outdir. Anything other than .class files in the directory (or its
- * subdirectories) are considered resources and are also copied.
+ * Add any .class files in the directory to the outdir. Anything other than
+ * .class files in the directory (or its subdirectories) are considered
+ * resources and are also copied.
*
*/
- public List addDirectoryContents(File inFile, File outDir) throws IOException {
+ public List addDirectoryContents(File inFile, File outDir)
+ throws IOException {
List addedClassFiles = new ArrayList();
// Get a list of all files (i.e. everything that isnt a directory)
byte[] bytes = FileUtil.readAsByteArray(inStream);
String filename = entry.getName();
- // System.out.println("? addJarFile() filename='" + filename + "'");
- UnwovenClassFile classFile = new UnwovenClassFile(new File(outDir, filename).getAbsolutePath(), bytes);
+ // System.out.println("? addJarFile() filename='" + filename
+ // + "'");
+ UnwovenClassFile classFile = new UnwovenClassFile(new File(
+ outDir, filename).getAbsolutePath(), bytes);
if (filename.endsWith(".class")) {
this.addClassFile(classFile);
inJar.close();
}
} catch (FileNotFoundException ex) {
- IMessage message = new Message("Could not find input jar file " + inFile.getPath() + ", ignoring", new SourceLocation(
+ IMessage message = new Message("Could not find input jar file "
+ + inFile.getPath() + ", ignoring", new SourceLocation(
inFile, 0), false);
world.getMessageHandler().handleMessage(message);
} catch (IOException ex) {
- IMessage message = new Message("Could not read input jar file " + inFile.getPath() + "(" + ex.getMessage() + ")",
+ IMessage message = new Message("Could not read input jar file "
+ + inFile.getPath() + "(" + ex.getMessage() + ")",
new SourceLocation(inFile, 0), true);
world.getMessageHandler().handleMessage(message);
} finally {
try {
inJar.close();
} catch (IOException ex) {
- IMessage message = new Message("Could not close input jar file " + inFile.getPath() + "(" + ex.getMessage()
- + ")", new SourceLocation(inFile, 0), true);
+ IMessage message = new Message(
+ "Could not close input jar file "
+ + inFile.getPath() + "(" + ex.getMessage()
+ + ")", new SourceLocation(inFile, 0), true);
world.getMessageHandler().handleMessage(message);
}
}
return addedClassFiles;
}
- // public void addResource(String name, File inPath, File outDir) throws IOException {
+ // public void addResource(String name, File inPath, File outDir) throws
+ // IOException {
//
// /* Eliminate CVS files. Relative paths use "/" */
- // if (!name.startsWith("CVS/") && (-1 == name.indexOf("/CVS/")) && !name.endsWith("/CVS")) {
+ // if (!name.startsWith("CVS/") && (-1 == name.indexOf("/CVS/")) &&
+ // !name.endsWith("/CVS")) {
// // System.err.println("? addResource('" + name + "')");
- // // BufferedInputStream inStream = new BufferedInputStream(new FileInputStream(inPath));
+ // // BufferedInputStream inStream = new BufferedInputStream(new
+ // FileInputStream(inPath));
// // byte[] bytes = new byte[(int)inPath.length()];
// // inStream.read(bytes);
// // inStream.close();
// byte[] bytes = FileUtil.readAsByteArray(inPath);
- // UnwovenClassFile resourceFile = new UnwovenClassFile(new File(outDir, name).getAbsolutePath(), bytes);
+ // UnwovenClassFile resourceFile = new UnwovenClassFile(new File(outDir,
+ // name).getAbsolutePath(), bytes);
// addResource(name,resourceFile);
// }
// }
*/
public void addClassFile(UnwovenClassFile classFile) {
addedClasses.add(classFile);
- // if (null != sourceJavaClasses.put(classFile.getClassName(), classFile)) {
+ // if (null != sourceJavaClasses.put(classFile.getClassName(),
+ // classFile)) {
// // throw new RuntimeException(classFile.getClassName());
// }
world.addSourceObjectType(classFile.getJavaClass());
}
- public UnwovenClassFile addClassFile(File classFile, File inPathDir, File outDir) throws IOException {
+ public UnwovenClassFile addClassFile(File classFile, File inPathDir,
+ File outDir) throws IOException {
FileInputStream fis = new FileInputStream(classFile);
byte[] bytes = FileUtil.readAsByteArray(fis);
// String relativePath = files[i].getPath();
- // ASSERT: files[i].getAbsolutePath().startsWith(inFile.getAbsolutePath()
+ // ASSERT:
+ // files[i].getAbsolutePath().startsWith(inFile.getAbsolutePath()
// or we are in trouble...
- String filename = classFile.getAbsolutePath().substring(inPathDir.getAbsolutePath().length() + 1);
- UnwovenClassFile ucf = new UnwovenClassFile(new File(outDir, filename).getAbsolutePath(), bytes);
+ String filename = classFile.getAbsolutePath().substring(
+ inPathDir.getAbsolutePath().length() + 1);
+ UnwovenClassFile ucf = new UnwovenClassFile(new File(outDir, filename)
+ .getAbsolutePath(), bytes);
if (filename.endsWith(".class")) {
- // System.err.println("BCELWeaver: processing class from input directory "+classFile);
+ // System.err.println(
+ // "BCELWeaver: processing class from input directory "+classFile);
this.addClassFile(ucf);
}
fis.close();
UnwovenClassFile jc = (UnwovenClassFile) i.next();
String name = jc.getClassName();
ResolvedType type = world.resolve(name);
- // System.err.println("added: " + type + " aspect? " + type.isAspect());
+ // System.err.println("added: " + type + " aspect? " +
+ // type.isAspect());
if (type.isAspect()) {
needToReweaveWorld |= xcutSet.addOrReplaceAspect(type);
}
shadowMungerList = xcutSet.getShadowMungers();
// world.debug("shadow mungers=" + shadowMungerList);
rewritePointcuts(shadowMungerList);
- // Sometimes an error occurs during rewriting pointcuts (for example, if ambiguous bindings
- // are detected) - we ought to fail the prepare when this happens because continuing with
+ // Sometimes an error occurs during rewriting pointcuts (for example, if
+ // ambiguous bindings
+ // are detected) - we ought to fail the prepare when this happens
+ // because continuing with
// inconsistent pointcuts could lead to problems
typeMungerList = xcutSet.getTypeMungers();
lateTypeMungerList = xcutSet.getLateTypeMungers();
addCustomMungers();
- // The ordering here used to be based on a string compare on toString() for the two mungers -
- // that breaks for the @AJ style where advice names aren't programmatically generated. So we
- // have changed the sorting to be based on source location in the file - this is reliable, in
- // the case of source locations missing, we assume they are 'sorted' - i.e. the order in
- // which they were added to the collection is correct, this enables the @AJ stuff to work properly.
-
- // When @AJ processing starts filling in source locations for mungers, this code may need
+ // The ordering here used to be based on a string compare on toString()
+ // for the two mungers -
+ // that breaks for the @AJ style where advice names aren't
+ // programmatically generated. So we
+ // have changed the sorting to be based on source location in the file -
+ // this is reliable, in
+ // the case of source locations missing, we assume they are 'sorted' -
+ // i.e. the order in
+ // which they were added to the collection is correct, this enables the
+ // @AJ stuff to work properly.
+
+ // When @AJ processing starts filling in source locations for mungers,
+ // this code may need
// a bit of alteration...
Collections.sort(shadowMungerList, new Comparator() {
if (sm2.getSourceLocation() == null)
return -1;
- return (sm2.getSourceLocation().getOffset() - sm1.getSourceLocation().getOffset());
+ return (sm2.getSourceLocation().getOffset() - sm1
+ .getSourceLocation().getOffset());
}
});
if (inReweavableMode)
- world.showMessage(IMessage.INFO, WeaverMessages.format(WeaverMessages.REWEAVABLE_MODE), null, null);
+ world.showMessage(IMessage.INFO, WeaverMessages
+ .format(WeaverMessages.REWEAVABLE_MODE), null, null);
if (trace.isTraceEnabled())
trace.exit("prepareForWeave");
String name = jc.getClassName();
ResolvedType type = world.resolve(name);
if (type.isAspect()) {
- Collection/* ShadowMunger */shadowMungers = customMungerFactory.createCustomShadowMungers(type);
+ Collection/* ShadowMunger */shadowMungers = customMungerFactory
+ .createCustomShadowMungers(type);
if (shadowMungers != null) {
shadowMungerList.addAll(shadowMungers);
}
- Collection/* ConcreteTypeMunger */typeMungers = customMungerFactory.createCustomTypeMungers(type);
+ Collection/* ConcreteTypeMunger */typeMungers = customMungerFactory
+ .createCustomTypeMungers(type);
if (typeMungers != null)
typeMungerList.addAll(typeMungers);
}
}
/*
- * Rewrite all of the pointcuts in the world into their most efficient form for subsequent matching. Also ensure that if
- * pc1.equals(pc2) then pc1 == pc2 (for non-binding pcds) by making references all point to the same instance. Since pointcuts
- * remember their match decision on the last shadow, this makes matching faster when many pointcuts share common elements, or
- * even when one single pointcut has one common element (which can be a side-effect of DNF rewriting).
+ * Rewrite all of the pointcuts in the world into their most efficient form
+ * for subsequent matching. Also ensure that if pc1.equals(pc2) then pc1 ==
+ * pc2 (for non-binding pcds) by making references all point to the same
+ * instance. Since pointcuts remember their match decision on the last
+ * shadow, this makes matching faster when many pointcuts share common
+ * elements, or even when one single pointcut has one common element (which
+ * can be a side-effect of DNF rewriting).
*/
private void rewritePointcuts(List/* ShadowMunger */shadowMungers) {
PointcutRewriter rewriter = new PointcutRewriter();
if (advice.getSignature() != null) {
final int numFormals;
final String names[];
- // If the advice is being concretized in a @AJ aspect *and* the advice was declared in
- // an @AJ aspect (it could have been inherited from a code style aspect) then
+ // If the advice is being concretized in a @AJ aspect *and*
+ // the advice was declared in
+ // an @AJ aspect (it could have been inherited from a code
+ // style aspect) then
// evaluate the alternative set of formals. pr125699
- if (advice.getConcreteAspect().isAnnotationStyleAspect() && advice.getDeclaringAspect() != null
- && advice.getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) {
+ if (advice.getConcreteAspect().isAnnotationStyleAspect()
+ && advice.getDeclaringAspect() != null
+ && advice.getDeclaringAspect().resolve(world)
+ .isAnnotationStyleAspect()) {
numFormals = advice.getBaseParameterCount();
int numArgs = advice.getSignature().getParameterTypes().length;
if (numFormals > 0) {
- names = advice.getSignature().getParameterNames(world);
+ names = advice.getSignature().getParameterNames(
+ world);
validateBindings(newP, p, numArgs, names);
}
} else {
// userPointcut is the pointcut that the user wrote in the program text.
// dnfPointcut is the same pointcut rewritten in DNF
// numFormals is the number of formal parameters in the pointcut
- // if numFormals > 0 then every branch of a disjunction must bind each formal once and only once.
- // in addition, the left and right branches of a disjunction must hold on join point kinds in
+ // if numFormals > 0 then every branch of a disjunction must bind each
+ // formal once and only once.
+ // in addition, the left and right branches of a disjunction must hold on
+ // join point kinds in
// common.
- private void validateBindings(Pointcut dnfPointcut, Pointcut userPointcut, int numFormals, String[] names) {
+ private void validateBindings(Pointcut dnfPointcut, Pointcut userPointcut,
+ int numFormals, String[] names) {
if (numFormals == 0)
return; // nothing to check
if (dnfPointcut.couldMatchKinds() == Shadow.NO_SHADOW_KINDS_BITS)
OrPointcut orBasedDNFPointcut = (OrPointcut) dnfPointcut;
Pointcut[] leftBindings = new Pointcut[numFormals];
Pointcut[] rightBindings = new Pointcut[numFormals];
- validateOrBranch(orBasedDNFPointcut, userPointcut, numFormals, names, leftBindings, rightBindings);
+ validateOrBranch(orBasedDNFPointcut, userPointcut, numFormals,
+ names, leftBindings, rightBindings);
} else {
Pointcut[] bindings = new Pointcut[numFormals];
- validateSingleBranch(dnfPointcut, userPointcut, numFormals, names, bindings);
+ validateSingleBranch(dnfPointcut, userPointcut, numFormals, names,
+ bindings);
}
}
- private void validateOrBranch(OrPointcut pc, Pointcut userPointcut, int numFormals, String[] names, Pointcut[] leftBindings,
+ private void validateOrBranch(OrPointcut pc, Pointcut userPointcut,
+ int numFormals, String[] names, Pointcut[] leftBindings,
Pointcut[] rightBindings) {
Pointcut left = pc.getLeft();
Pointcut right = pc.getRight();
if (left instanceof OrPointcut) {
Pointcut[] newRightBindings = new Pointcut[numFormals];
- validateOrBranch((OrPointcut) left, userPointcut, numFormals, names, leftBindings, newRightBindings);
+ validateOrBranch((OrPointcut) left, userPointcut, numFormals,
+ names, leftBindings, newRightBindings);
} else {
if (left.couldMatchKinds() != Shadow.NO_SHADOW_KINDS_BITS)
- validateSingleBranch(left, userPointcut, numFormals, names, leftBindings);
+ validateSingleBranch(left, userPointcut, numFormals, names,
+ leftBindings);
}
if (right instanceof OrPointcut) {
Pointcut[] newLeftBindings = new Pointcut[numFormals];
- validateOrBranch((OrPointcut) right, userPointcut, numFormals, names, newLeftBindings, rightBindings);
+ validateOrBranch((OrPointcut) right, userPointcut, numFormals,
+ names, newLeftBindings, rightBindings);
} else {
if (right.couldMatchKinds() != Shadow.NO_SHADOW_KINDS_BITS)
- validateSingleBranch(right, userPointcut, numFormals, names, rightBindings);
+ validateSingleBranch(right, userPointcut, numFormals, names,
+ rightBindings);
}
int kindsInCommon = left.couldMatchKinds() & right.couldMatchKinds();
- if (kindsInCommon != Shadow.NO_SHADOW_KINDS_BITS && couldEverMatchSameJoinPoints(left, right)) {
- // we know that every branch binds every formal, so there is no ambiguity
+ if (kindsInCommon != Shadow.NO_SHADOW_KINDS_BITS
+ && couldEverMatchSameJoinPoints(left, right)) {
+ // we know that every branch binds every formal, so there is no
+ // ambiguity
// if each branch binds it in exactly the same way...
List ambiguousNames = new ArrayList();
for (int i = 0; i < numFormals; i++) {
// pc is a pointcut that does not contain any disjunctions
// check that every formal is bound (negation doesn't count).
// we know that numFormals > 0 or else we would not be called
- private void validateSingleBranch(Pointcut pc, Pointcut userPointcut, int numFormals, String[] names, Pointcut[] bindings) {
+ private void validateSingleBranch(Pointcut pc, Pointcut userPointcut,
+ int numFormals, String[] names, Pointcut[] bindings) {
boolean[] foundFormals = new boolean[numFormals];
for (int i = 0; i < foundFormals.length; i++) {
foundFormals[i] = false;
}
- validateSingleBranchRecursion(pc, userPointcut, foundFormals, names, bindings);
+ validateSingleBranchRecursion(pc, userPointcut, foundFormals, names,
+ bindings);
for (int i = 0; i < foundFormals.length; i++) {
if (!foundFormals[i]) {
boolean ignore = false;
- // ATAJ soften the unbound error for implicit bindings like JoinPoint in @AJ style
+ // ATAJ soften the unbound error for implicit bindings like
+ // JoinPoint in @AJ style
for (int j = 0; j < userPointcut.m_ignoreUnboundBindingForNames.length; j++) {
- if (names[i] != null && names[i].equals(userPointcut.m_ignoreUnboundBindingForNames[j])) {
+ if (names[i] != null
+ && names[i]
+ .equals(userPointcut.m_ignoreUnboundBindingForNames[j])) {
ignore = true;
break;
}
}
// each formal must appear exactly once
- private void validateSingleBranchRecursion(Pointcut pc, Pointcut userPointcut, boolean[] foundFormals, String[] names,
+ private void validateSingleBranchRecursion(Pointcut pc,
+ Pointcut userPointcut, boolean[] foundFormals, String[] names,
Pointcut[] bindings) {
if (pc instanceof NotPointcut) {
// nots can only appear at leaves in DNF
NotPointcut not = (NotPointcut) pc;
if (not.getNegatedPointcut() instanceof NameBindingPointcut) {
- NameBindingPointcut nnbp = (NameBindingPointcut) not.getNegatedPointcut();
- if (!nnbp.getBindingAnnotationTypePatterns().isEmpty() && !nnbp.getBindingTypePatterns().isEmpty())
+ NameBindingPointcut nnbp = (NameBindingPointcut) not
+ .getNegatedPointcut();
+ if (!nnbp.getBindingAnnotationTypePatterns().isEmpty()
+ && !nnbp.getBindingTypePatterns().isEmpty())
raiseNegationBindingError(userPointcut);
}
} else if (pc instanceof AndPointcut) {
AndPointcut and = (AndPointcut) pc;
- validateSingleBranchRecursion(and.getLeft(), userPointcut, foundFormals, names, bindings);
- validateSingleBranchRecursion(and.getRight(), userPointcut, foundFormals, names, bindings);
+ validateSingleBranchRecursion(and.getLeft(), userPointcut,
+ foundFormals, names, bindings);
+ validateSingleBranchRecursion(and.getRight(), userPointcut,
+ foundFormals, names, bindings);
} else if (pc instanceof NameBindingPointcut) {
- List/* BindingTypePattern */btps = ((NameBindingPointcut) pc).getBindingTypePatterns();
+ List/* BindingTypePattern */btps = ((NameBindingPointcut) pc)
+ .getBindingTypePatterns();
for (Iterator iter = btps.iterator(); iter.hasNext();) {
BindingTypePattern btp = (BindingTypePattern) iter.next();
int index = btp.getFormalIndex();
foundFormals[index] = true;
}
}
- List/* BindingPattern */baps = ((NameBindingPointcut) pc).getBindingAnnotationTypePatterns();
+ List/* BindingPattern */baps = ((NameBindingPointcut) pc)
+ .getBindingAnnotationTypePatterns();
for (Iterator iter = baps.iterator(); iter.hasNext();) {
BindingPattern bap = (BindingPattern) iter.next();
int index = bap.getFormalIndex();
}
// look for withins
- WithinPointcut leftWithin = (WithinPointcut) findFirstPointcutIn(left, WithinPointcut.class);
- WithinPointcut rightWithin = (WithinPointcut) findFirstPointcutIn(right, WithinPointcut.class);
+ WithinPointcut leftWithin = (WithinPointcut) findFirstPointcutIn(left,
+ WithinPointcut.class);
+ WithinPointcut rightWithin = (WithinPointcut) findFirstPointcutIn(
+ right, WithinPointcut.class);
if ((leftWithin != null) && (rightWithin != null)) {
if (!leftWithin.couldEverMatchSameJoinPointsAs(rightWithin))
return false;
}
// look for kinded
- KindedPointcut leftKind = (KindedPointcut) findFirstPointcutIn(left, KindedPointcut.class);
- KindedPointcut rightKind = (KindedPointcut) findFirstPointcutIn(right, KindedPointcut.class);
+ KindedPointcut leftKind = (KindedPointcut) findFirstPointcutIn(left,
+ KindedPointcut.class);
+ KindedPointcut rightKind = (KindedPointcut) findFirstPointcutIn(right,
+ KindedPointcut.class);
if ((leftKind != null) && (rightKind != null)) {
if (!leftKind.couldEverMatchSameJoinPointsAs(rightKind))
return false;
* @param userPointcut
*/
private void raiseNegationBindingError(Pointcut userPointcut) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.NEGATION_DOESNT_ALLOW_BINDING), userPointcut
- .getSourceContext().makeSourceLocation(userPointcut), null);
+ world.showMessage(IMessage.ERROR, WeaverMessages
+ .format(WeaverMessages.NEGATION_DOESNT_ALLOW_BINDING),
+ userPointcut.getSourceContext()
+ .makeSourceLocation(userPointcut), null);
}
/**
* @param userPointcut
*/
private void raiseAmbiguousBindingError(String name, Pointcut userPointcut) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING, name), userPointcut
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.AMBIGUOUS_BINDING, name), userPointcut
.getSourceContext().makeSourceLocation(userPointcut), null);
}
/**
* @param userPointcut
*/
- private void raiseAmbiguityInDisjunctionError(Pointcut userPointcut, List names) {
+ private void raiseAmbiguityInDisjunctionError(Pointcut userPointcut,
+ List names) {
StringBuffer formalNames = new StringBuffer(names.get(0).toString());
for (int i = 1; i < names.size(); i++) {
formalNames.append(", ");
formalNames.append(names.get(i));
}
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING_IN_OR, formalNames), userPointcut
- .getSourceContext().makeSourceLocation(userPointcut), null);
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.AMBIGUOUS_BINDING_IN_OR, formalNames),
+ userPointcut.getSourceContext()
+ .makeSourceLocation(userPointcut), null);
}
/**
* @param userPointcut
*/
private void raiseUnboundFormalError(String name, Pointcut userPointcut) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.UNBOUND_FORMAL, name), userPointcut
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(
+ WeaverMessages.UNBOUND_FORMAL, name), userPointcut
.getSourceLocation(), null);
}
// }
// public void dumpResourcesToOutPath() throws IOException {
- // // System.err.println("? dumpResourcesToOutPath() resources=" + resources.keySet());
+ // // System.err.println("? dumpResourcesToOutPath() resources=" +
+ // resources.keySet());
// Iterator i = resources.keySet().iterator();
// while (i.hasNext()) {
// UnwovenClassFile res = (UnwovenClassFile)resources.get(i.next());
//
/* BUG #40943 */
// public void dumpResourcesToOutJar() throws IOException {
- // // System.err.println("? dumpResourcesToOutJar() resources=" + resources.keySet());
+ // // System.err.println("? dumpResourcesToOutJar() resources=" +
+ // resources.keySet());
// Iterator i = resources.keySet().iterator();
// while (i.hasNext()) {
// String name = (String)i.next();
// resources = new HashMap();
// }
//
- // // halfway house for when the jar is managed outside of the weaver, but the resources
+ // // halfway house for when the jar is managed outside of the weaver, but
+ // the resources
// // to be copied are known in the weaver.
- // public void dumpResourcesToOutJar(ZipOutputStream zos) throws IOException {
+ // public void dumpResourcesToOutJar(ZipOutputStream zos) throws IOException
+ // {
// this.zipOutputStream = zos;
// dumpResourcesToOutJar();
// }
// for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
// UnwovenClassFile classFile = (UnwovenClassFile)i.next();
// String className = classFile.getClassName();
- // BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
+ // BcelObjectType classType =
+ // BcelWorld.getBcelObjectType(world.resolve(className));
// if (classType.isAspect()) {
// weave(classFile, classType);
// wovenClassNames.add(className);
// for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
// UnwovenClassFile classFile = (UnwovenClassFile)i.next();
// String className = classFile.getClassName();
- // BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
+ // BcelObjectType classType =
+ // BcelWorld.getBcelObjectType(world.resolve(className));
// if (! classType.isAspect()) {
// weave(classFile, classType);
// wovenClassNames.add(className);
public Collection weave(IClassFileProvider input) throws IOException {
if (trace.isTraceEnabled())
trace.enter("weave", this, input);
- ContextToken weaveToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING, "");
+ ContextToken weaveToken = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.WEAVING, "");
Collection wovenClassNames = new ArrayList();
IWeaveRequestor requestor = input.getRequestor();
for (Iterator i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = (UnwovenClassFile) i.next();
if (AsmManager.isCreatingModel() && !isBatchWeave) {
- // remove all relationships where this file being woven is the target of the relationship
- AsmManager.getDefault().removeRelationshipsTargettingThisType(classFile.getClassName());
+ // remove all relationships where this file being woven is the
+ // target of the relationship
+ AsmManager.getDefault().removeRelationshipsTargettingThisType(
+ classFile.getClassName());
}
}
- // Go through the types and ensure any 'damaged' during compile time are repaired prior to weaving
+ // Go through the types and ensure any 'damaged' during compile time are
+ // repaired prior to weaving
for (Iterator i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = (UnwovenClassFile) i.next();
String className = classFile.getClassName();
// special case for AtAspectJMungerOnly - see #113587
if (input.isApplyAtAspectJMungersOnly()) {
- ContextToken atAspectJMungersOnly = CompilationAndWeavingContext.enteringPhase(
- CompilationAndWeavingContext.PROCESSING_ATASPECTJTYPE_MUNGERS_ONLY, "");
+ ContextToken atAspectJMungersOnly = CompilationAndWeavingContext
+ .enteringPhase(
+ CompilationAndWeavingContext.PROCESSING_ATASPECTJTYPE_MUNGERS_ONLY,
+ "");
requestor.weavingAspects();
// ContextToken aspectToken =
- CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_ASPECTS, "");
+ CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.WEAVING_ASPECTS, "");
for (Iterator i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = (UnwovenClassFile) i.next();
String className = classFile.getClassName();
ResolvedType theType = world.resolve(className);
if (theType.isAnnotationStyleAspect()) {
- BcelObjectType classType = BcelWorld.getBcelObjectType(theType);
+ BcelObjectType classType = BcelWorld
+ .getBcelObjectType(theType);
if (classType == null) {
- throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
+ throw new BCException("Can't find bcel delegate for "
+ + className + " type=" + theType.getClass());
}
LazyClassGen clazz = classType.getLazyClassGen();
- BcelPerClauseAspectAdder selfMunger = new BcelPerClauseAspectAdder(theType, theType.getPerClause().getKind());
+ BcelPerClauseAspectAdder selfMunger = new BcelPerClauseAspectAdder(
+ theType, theType.getPerClause().getKind());
selfMunger.forceMunge(clazz, true);
classType.finishedWith();
UnwovenClassFile[] newClasses = getClassFilesFor(clazz);
String className = classFile.getClassName();
BcelObjectType classType = getClassType(className);
- // null return from getClassType() means the delegate is an eclipse source type - so
+ // null return from getClassType() means the delegate is an eclipse
+ // source type - so
// there *cant* be any reweavable state... (he bravely claimed...)
if (classType != null) {
- ContextToken tok = CompilationAndWeavingContext.enteringPhase(
- CompilationAndWeavingContext.PROCESSING_REWEAVABLE_STATE, className);
+ ContextToken tok = CompilationAndWeavingContext
+ .enteringPhase(
+ CompilationAndWeavingContext.PROCESSING_REWEAVABLE_STATE,
+ className);
processReweavableStateIfPresent(className, classType);
CompilationAndWeavingContext.leavingPhase(tok);
}
CompilationAndWeavingContext.leavingPhase(reweaveToken);
- ContextToken typeMungingToken = CompilationAndWeavingContext.enteringPhase(
- CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS, "");
+ ContextToken typeMungingToken = CompilationAndWeavingContext
+ .enteringPhase(
+ CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS,
+ "");
requestor.addingTypeMungers();
- // We process type mungers in two groups, first mungers that change the type
+ // We process type mungers in two groups, first mungers that change the
+ // type
// hierarchy, then 'normal' ITD type mungers.
- // Process the types in a predictable order (rather than the order encountered).
+ // Process the types in a predictable order (rather than the order
+ // encountered).
// For class A, the order is superclasses of A then superinterfaces of A
// (and this mechanism is applied recursively)
List typesToProcess = new ArrayList();
CompilationAndWeavingContext.leavingPhase(typeMungingToken);
requestor.weavingAspects();
- ContextToken aspectToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_ASPECTS, "");
+ ContextToken aspectToken = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.WEAVING_ASPECTS, "");
// first weave into aspects
for (Iterator i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = (UnwovenClassFile) i.next();
BcelObjectType classType = BcelWorld.getBcelObjectType(theType);
if (classType == null) {
- // Sometimes.. if the Bcel Delegate couldn't be found then a problem occurred at compile time - on
- // a previous compiler run. In this case I assert the delegate will still be an EclipseSourceType
- // and we can ignore the problem here (the original compile error will be reported again from
+ // Sometimes.. if the Bcel Delegate couldn't be found then a
+ // problem occurred at compile time - on
+ // a previous compiler run. In this case I assert the
+ // delegate will still be an EclipseSourceType
+ // and we can ignore the problem here (the original compile
+ // error will be reported again from
// the eclipse source type) - pr113531
- ReferenceTypeDelegate theDelegate = ((ReferenceType) theType).getDelegate();
- if (theDelegate.getClass().getName().endsWith("EclipseSourceType"))
+ ReferenceTypeDelegate theDelegate = ((ReferenceType) theType)
+ .getDelegate();
+ if (theDelegate.getClass().getName().endsWith(
+ "EclipseSourceType"))
continue;
- throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
+ throw new BCException("Can't find bcel delegate for "
+ + className + " type=" + theType.getClass());
}
weaveAndNotify(classFile, classType, requestor);
wovenClassNames.add(className);
CompilationAndWeavingContext.leavingPhase(aspectToken);
requestor.weavingClasses();
- ContextToken classToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_CLASSES, "");
+ ContextToken classToken = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.WEAVING_CLASSES, "");
// then weave into non-aspects
for (Iterator i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = (UnwovenClassFile) i.next();
if (classType == null) {
// bug 119882 - see above comment for bug 113531
- ReferenceTypeDelegate theDelegate = ((ReferenceType) theType).getDelegate();
+ ReferenceTypeDelegate theDelegate = ((ReferenceType) theType)
+ .getDelegate();
- // TODO urgh - put a method on the interface to check this, string compare is hideous
- if (theDelegate.getClass().getName().endsWith("EclipseSourceType"))
+ // TODO urgh - put a method on the interface to check this,
+ // string compare is hideous
+ if (theDelegate.getClass().getName().endsWith(
+ "EclipseSourceType"))
continue;
- throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
+ throw new BCException("Can't find bcel delegate for "
+ + className + " type=" + theType.getClass());
}
weaveAndNotify(classFile, classType, requestor);
wovenClassNames.add(className);
}
/**
- * In 1.5 mode and with XLint:adviceDidNotMatch enabled, put out messages for any mungers that did not match anything.
+ * In 1.5 mode and with XLint:adviceDidNotMatch enabled, put out messages
+ * for any mungers that did not match anything.
*/
private void warnOnUnmatchedAdvice() {
}
}
- // FIXME asc Should be factored out into Xlint code and done automatically for all xlint messages, ideally.
- // if a piece of advice hasn't matched anywhere and we are in -1.5 mode, put out a warning
- if (world.isInJava5Mode() && world.getLint().adviceDidNotMatch.isEnabled()) {
+ // FIXME asc Should be factored out into Xlint code and done
+ // automatically for all xlint messages, ideally.
+ // if a piece of advice hasn't matched anywhere and we are in -1.5 mode,
+ // put out a warning
+ if (world.isInJava5Mode()
+ && world.getLint().adviceDidNotMatch.isEnabled()) {
List l = world.getCrosscuttingMembersSet().getShadowMungers();
Set alreadyWarnedLocations = new HashSet();
for (Iterator iter = l.iterator(); iter.hasNext();) {
ShadowMunger element = (ShadowMunger) iter.next();
- if (element instanceof BcelAdvice) { // This will stop us incorrectly reporting deow Checkers
+ if (element instanceof BcelAdvice) { // This will stop us
+ // incorrectly reporting
+ // deow Checkers
BcelAdvice ba = (BcelAdvice) element;
if (!ba.hasMatchedSomething()) {
- // Because we implement some features of AJ itself by creating our own kind of mungers, you sometimes
- // find that ba.getSignature() is not a BcelMethod - for example it might be a cflow entry munger.
+ // Because we implement some features of AJ itself by
+ // creating our own kind of mungers, you sometimes
+ // find that ba.getSignature() is not a BcelMethod - for
+ // example it might be a cflow entry munger.
if (ba.getSignature() != null) {
- // check we haven't already warned on this advice and line
- // (cflow creates multiple mungers for the same advice)
+ // check we haven't already warned on this advice
+ // and line
+ // (cflow creates multiple mungers for the same
+ // advice)
AdviceLocation loc = new AdviceLocation(ba);
if (alreadyWarnedLocations.contains(loc)) {
continue;
}
if (!(ba.getSignature() instanceof BcelMethod)
- || !Utility.isSuppressing(ba.getSignature(), "adviceDidNotMatch")) {
- world.getLint().adviceDidNotMatch.signal(ba.getDeclaringAspect().toString(), new SourceLocation(
- element.getSourceLocation().getSourceFile(), element.getSourceLocation().getLine()));// element
+ || !Utility.isSuppressing(
+ ba.getSignature(),
+ "adviceDidNotMatch")) {
+ world.getLint().adviceDidNotMatch
+ .signal(
+ ba.getDeclaringAspect()
+ .toString(),
+ new SourceLocation(
+ element
+ .getSourceLocation()
+ .getSourceFile(),
+ element
+ .getSourceLocation()
+ .getLine()));// element
// .
// getSourceLocation
// (
}
/**
- * 'typeToWeave' is one from the 'typesForWeaving' list. This routine ensures we process supertypes (classes/interfaces) of
- * 'typeToWeave' that are in the 'typesForWeaving' list before 'typeToWeave' itself. 'typesToWeave' is then removed from the
- * 'typesForWeaving' list.
+ * 'typeToWeave' is one from the 'typesForWeaving' list. This routine
+ * ensures we process supertypes (classes/interfaces) of 'typeToWeave' that
+ * are in the 'typesForWeaving' list before 'typeToWeave' itself.
+ * 'typesToWeave' is then removed from the 'typesForWeaving' list.
*
- * Note: Future gotcha in here ... when supplying partial hierarchies, this algorithm may break down. If you have a hierarchy
- * A>B>C and only give A and C to the weaver, it may choose to weave them in either order - but you'll probably have other
- * problems if you are supplying partial hierarchies like that !
+ * Note: Future gotcha in here ... when supplying partial hierarchies, this
+ * algorithm may break down. If you have a hierarchy A>B>C and only give A
+ * and C to the weaver, it may choose to weave them in either order - but
+ * you'll probably have other problems if you are supplying partial
+ * hierarchies like that !
*/
private void weaveParentsFor(List typesForWeaving, String typeToWeave) {
// Look at the supertype first
weaveParentsFor(typesForWeaving, rtxI.getName());
}
}
- ContextToken tok = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.PROCESSING_DECLARE_PARENTS, rtx
- .getName());
+ ContextToken tok = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.PROCESSING_DECLARE_PARENTS, rtx
+ .getName());
weaveParentTypeMungers(rtx); // Now do this type
CompilationAndWeavingContext.leavingPhase(tok);
- typesForWeaving.remove(typeToWeave); // and remove it from the list of those to process
+ typesForWeaving.remove(typeToWeave); // and remove it from the list of
+ // those to process
}
public void prepareToProcessReweavableState() {
}
- public void processReweavableStateIfPresent(String className, BcelObjectType classType) {
- // If the class is marked reweavable, check any aspects around when it was built are in this world
+ public void processReweavableStateIfPresent(String className,
+ BcelObjectType classType) {
+ // If the class is marked reweavable, check any aspects around when it
+ // was built are in this world
WeaverStateInfo wsi = classType.getWeaverState();
- if (wsi != null && wsi.isReweavable()) { // Check all necessary types are around!
- world.showMessage(IMessage.INFO, WeaverMessages.format(WeaverMessages.PROCESSING_REWEAVABLE, className, classType
- .getSourceLocation().getSourceFile()), null, null);
+ if (wsi != null && wsi.isReweavable()) { // Check all necessary types
+ // are around!
+ world.showMessage(IMessage.INFO, WeaverMessages.format(
+ WeaverMessages.PROCESSING_REWEAVABLE, className, classType
+ .getSourceLocation().getSourceFile()), null, null);
Set aspectsPreviouslyInWorld = wsi.getAspectsAffectingType();
if (aspectsPreviouslyInWorld != null) {
- // keep track of them just to ensure unique missing aspect error reporting
+ // keep track of them just to ensure unique missing aspect error
+ // reporting
Set alreadyConfirmedReweavableState = new HashSet();
- for (Iterator iter = aspectsPreviouslyInWorld.iterator(); iter.hasNext();) {
+ for (Iterator iter = aspectsPreviouslyInWorld.iterator(); iter
+ .hasNext();) {
String requiredTypeName = (String) iter.next();
- if (!alreadyConfirmedReweavableState.contains(requiredTypeName)) {
- ResolvedType rtx = world.resolve(UnresolvedType.forName(requiredTypeName), true);
+ if (!alreadyConfirmedReweavableState
+ .contains(requiredTypeName)) {
+ ResolvedType rtx = world.resolve(UnresolvedType
+ .forName(requiredTypeName), true);
boolean exists = !rtx.isMissing();
if (!exists) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.MISSING_REWEAVABLE_TYPE,
- requiredTypeName, className), classType.getSourceLocation(), null);
+ world
+ .showMessage(
+ IMessage.ERROR,
+ WeaverMessages
+ .format(
+ WeaverMessages.MISSING_REWEAVABLE_TYPE,
+ requiredTypeName,
+ className),
+ classType.getSourceLocation(), null);
} else {
- // weaved in aspect that are not declared in aop.xml trigger an error for now
- // may cause headhache for LTW and packaged lib without aop.xml in
+ // weaved in aspect that are not declared in aop.xml
+ // trigger an error for now
+ // may cause headhache for LTW and packaged lib
+ // without aop.xml in
// see #104218
if (!xcutSet.containsAspect(rtx)) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(
- WeaverMessages.REWEAVABLE_ASPECT_NOT_REGISTERED, requiredTypeName, className), null, null);
- } else if (!world.getMessageHandler().isIgnoring(IMessage.INFO))
- world.showMessage(IMessage.INFO, WeaverMessages.format(WeaverMessages.VERIFIED_REWEAVABLE_TYPE,
- requiredTypeName, rtx.getSourceLocation().getSourceFile()), null, null);
- alreadyConfirmedReweavableState.add(requiredTypeName);
+ world
+ .showMessage(
+ IMessage.ERROR,
+ WeaverMessages
+ .format(
+ WeaverMessages.REWEAVABLE_ASPECT_NOT_REGISTERED,
+ requiredTypeName,
+ className),
+ null, null);
+ } else if (!world.getMessageHandler().isIgnoring(
+ IMessage.INFO))
+ world
+ .showMessage(
+ IMessage.INFO,
+ WeaverMessages
+ .format(
+ WeaverMessages.VERIFIED_REWEAVABLE_TYPE,
+ requiredTypeName,
+ rtx
+ .getSourceLocation()
+ .getSourceFile()),
+ null, null);
+ alreadyConfirmedReweavableState
+ .add(requiredTypeName);
}
}
}
}
// old:
- // classType.setJavaClass(Utility.makeJavaClass(classType.getJavaClass().getFileName(), wsi.getUnwovenClassFileData()));
+ //classType.setJavaClass(Utility.makeJavaClass(classType.getJavaClass
+ // ().getFileName(), wsi.getUnwovenClassFileData()));
// new: reweavable default with clever diff
- classType.setJavaClass(Utility.makeJavaClass(classType.getJavaClass().getFileName(), wsi
- .getUnwovenClassFileData(classType.getJavaClass().getBytes())));
+ classType.setJavaClass(Utility.makeJavaClass(classType
+ .getJavaClass().getFileName(), wsi
+ .getUnwovenClassFileData(classType.getJavaClass()
+ .getBytes())));
// } else {
// classType.resetState();
}
}
- private void weaveAndNotify(UnwovenClassFile classFile, BcelObjectType classType, IWeaveRequestor requestor) throws IOException {
- trace.enter("weaveAndNotify", this, new Object[] { classFile, classType, requestor });
+ private void weaveAndNotify(UnwovenClassFile classFile,
+ BcelObjectType classType, IWeaveRequestor requestor)
+ throws IOException {
+ trace.enter("weaveAndNotify", this, new Object[] { classFile,
+ classType, requestor });
- ContextToken tok = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_TYPE, classType
- .getResolvedTypeX().getName());
+ ContextToken tok = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.WEAVING_TYPE, classType
+ .getResolvedTypeX().getName());
LazyClassGen clazz = weaveWithoutDump(classFile, classType);
classType.finishedWith();
// clazz is null if the classfile was unchanged by weaving...
if (clazz != null) {
UnwovenClassFile[] newClasses = getClassFilesFor(clazz);
- // OPTIMIZE can we avoid using the string name at all in UnwovenClassFile instances?
- // Copy the char[] across as it means the WeaverAdapter.removeFromMap() can be fast!
+ // OPTIMIZE can we avoid using the string name at all in
+ // UnwovenClassFile instances?
+ // Copy the char[] across as it means the
+ // WeaverAdapter.removeFromMap() can be fast!
if (newClasses[0].getClassName().equals(classFile.getClassName())) {
- newClasses[0].setClassNameAsChars(classFile.getClassNameAsChars());
+ newClasses[0].setClassNameAsChars(classFile
+ .getClassNameAsChars());
}
for (int i = 0; i < newClasses.length; i++) {
requestor.acceptResult(newClasses[i]);
trace.exit("weaveAndNotify");
}
- /** helper method - will return NULL if the underlying delegate is an EclipseSourceType and not a BcelObjectType */
+ /**
+ * helper method - will return NULL if the underlying delegate is an
+ * EclipseSourceType and not a BcelObjectType
+ */
public BcelObjectType getClassType(String forClass) {
return BcelWorld.getBcelObjectType(world.resolve(forClass));
}
public UnwovenClassFile[] getClassFilesFor(LazyClassGen clazz) {
List childClasses = clazz.getChildClasses(world);
UnwovenClassFile[] ret = new UnwovenClassFile[1 + childClasses.size()];
- ret[0] = new UnwovenClassFile(clazz.getFileName(), clazz.getClassName(), clazz.getJavaClassBytesIncludingReweavable(world));
+ ret[0] = new UnwovenClassFile(clazz.getFileName(),
+ clazz.getClassName(), clazz
+ .getJavaClassBytesIncludingReweavable(world));
int index = 1;
for (Iterator iter = childClasses.iterator(); iter.hasNext();) {
- UnwovenClassFile.ChildClass element = (UnwovenClassFile.ChildClass) iter.next();
- UnwovenClassFile childClass = new UnwovenClassFile(clazz.getFileName() + "$" + element.name, element.bytes);
+ UnwovenClassFile.ChildClass element = (UnwovenClassFile.ChildClass) iter
+ .next();
+ UnwovenClassFile childClass = new UnwovenClassFile(clazz
+ .getFileName()
+ + "$" + element.name, element.bytes);
ret[index++] = childClass;
}
return ret;
}
/**
- * Weaves new parents and annotations onto a type ("declare parents" and "declare @type")
+ * Weaves new parents and annotations onto a type ("declare parents" and
+ * "declare @type")
*
- * Algorithm: 1. First pass, do parents then do annotations. During this pass record: - any parent mungers that don't match but
- * have a non-wild annotation type pattern - any annotation mungers that don't match 2. Multiple subsequent passes which go over
- * the munger lists constructed in the first pass, repeatedly applying them until nothing changes. FIXME asc confirm that
- * algorithm is optimal ??
+ * Algorithm: 1. First pass, do parents then do annotations. During this
+ * pass record: - any parent mungers that don't match but have a non-wild
+ * annotation type pattern - any annotation mungers that don't match 2.
+ * Multiple subsequent passes which go over the munger lists constructed in
+ * the first pass, repeatedly applying them until nothing changes. FIXME asc
+ * confirm that algorithm is optimal ??
*/
public void weaveParentTypeMungers(ResolvedType onType) {
if (onType.isRawType())
}
// Still first pass - apply all dec @type mungers
- for (Iterator i = xcutSet.getDeclareAnnotationOnTypes().iterator(); i.hasNext();) {
+ for (Iterator i = xcutSet.getDeclareAnnotationOnTypes().iterator(); i
+ .hasNext();) {
DeclareAnnotation decA = (DeclareAnnotation) i.next();
boolean typeChanged = applyDeclareAtType(decA, onType, true);
if (typeChanged) {
}
}
- while ((aParentChangeOccurred || anAnnotationChangeOccurred) && !decpToRepeat.isEmpty()) {
+ while ((aParentChangeOccurred || anAnnotationChangeOccurred)
+ && !decpToRepeat.isEmpty()) {
anAnnotationChangeOccurred = aParentChangeOccurred = false;
List decpToRepeatNextTime = new ArrayList();
for (Iterator iter = decpToRepeat.iterator(); iter.hasNext();) {
}
}
- for (Iterator iter = xcutSet.getDeclareAnnotationOnTypes().iterator(); iter.hasNext();) {
+ for (Iterator iter = xcutSet.getDeclareAnnotationOnTypes()
+ .iterator(); iter.hasNext();) {
DeclareAnnotation decA = (DeclareAnnotation) iter.next();
boolean typeChanged = applyDeclareAtType(decA, onType, false);
if (typeChanged) {
/**
* Apply a declare @type - return true if we change the type
*/
- private boolean applyDeclareAtType(DeclareAnnotation decA, ResolvedType onType, boolean reportProblems) {
+ private boolean applyDeclareAtType(DeclareAnnotation decA,
+ ResolvedType onType, boolean reportProblems) {
boolean didSomething = false;
if (decA.matches(onType)) {
- if (onType.hasAnnotation(decA.getAnnotationX().getSignature())) {
+ if (onType.hasAnnotation(decA.getAnnotationX().getType())) {
// Could put out a lint here for an already annotated type ...
// if (reportProblems) {
// world.getLint().elementAlreadyAnnotated.signal(
- // new String[]{onType.toString(),decA.getAnnotationTypeX().toString()},
- // onType.getSourceLocation(),new ISourceLocation[]{decA.getSourceLocation()});
+ // new
+ // String[]{onType.toString(),decA.getAnnotationTypeX().toString
+ // ()},
+ // onType.getSourceLocation(),new
+ // ISourceLocation[]{decA.getSourceLocation()});
// }
return false;
}
- AnnotationX annoX = decA.getAnnotationX();
+ AnnotationAJ annoX = decA.getAnnotationX();
// check the annotation is suitable for the target
- boolean problemReported = verifyTargetIsOK(decA, onType, annoX, reportProblems);
+ boolean problemReported = verifyTargetIsOK(decA, onType, annoX,
+ reportProblems);
if (!problemReported) {
- AsmRelationshipProvider.getDefault().addDeclareAnnotationRelationship(decA.getSourceLocation(),
- onType.getSourceLocation());
+ AsmRelationshipProvider.getDefault()
+ .addDeclareAnnotationRelationship(
+ decA.getSourceLocation(),
+ onType.getSourceLocation());
// TAG: WeavingMessage
- if (!getWorld().getMessageHandler().isIgnoring(IMessage.WEAVEINFO)) {
+ if (!getWorld().getMessageHandler().isIgnoring(
+ IMessage.WEAVEINFO)) {
getWorld().getMessageHandler().handleMessage(
- WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ANNOTATES, new String[] {
- onType.toString(), Utility.beautifyLocation(onType.getSourceLocation()),
- decA.getAnnotationString(), "type", decA.getAspect().toString(),
- Utility.beautifyLocation(decA.getSourceLocation()) }));
+ WeaveMessage.constructWeavingMessage(
+ WeaveMessage.WEAVEMESSAGE_ANNOTATES,
+ new String[] {
+ onType.toString(),
+ Utility.beautifyLocation(onType
+ .getSourceLocation()),
+ decA.getAnnotationString(),
+ "type",
+ decA.getAspect().toString(),
+ Utility.beautifyLocation(decA
+ .getSourceLocation()) }));
}
didSomething = true;
- ResolvedTypeMunger newAnnotationTM = new AnnotationOnTypeMunger(annoX);
+ ResolvedTypeMunger newAnnotationTM = new AnnotationOnTypeMunger(
+ annoX);
newAnnotationTM.setSourceLocation(decA.getSourceLocation());
- onType.addInterTypeMunger(new BcelTypeMunger(newAnnotationTM, decA.getAspect().resolve(world)));
+ onType.addInterTypeMunger(new BcelTypeMunger(newAnnotationTM,
+ decA.getAspect().resolve(world)));
decA.copyAnnotationTo(onType);
}
}
}
/**
- * Checks for an @target() on the annotation and if found ensures it allows the annotation to be attached to the target type
- * that matched.
+ * Checks for an @target() on the annotation and if found ensures it allows
+ * the annotation to be attached to the target type that matched.
*/
- private boolean verifyTargetIsOK(DeclareAnnotation decA, ResolvedType onType, AnnotationX annoX, boolean outputProblems) {
+ private boolean verifyTargetIsOK(DeclareAnnotation decA,
+ ResolvedType onType, AnnotationAJ annoX, boolean outputProblems) {
boolean problemReported = false;
if (annoX.specifiesTarget()) {
- if ((onType.isAnnotation() && !annoX.allowedOnAnnotationType()) || (!annoX.allowedOnRegularType())) {
+ if ((onType.isAnnotation() && !annoX.allowedOnAnnotationType())
+ || (!annoX.allowedOnRegularType())) {
if (outputProblems) {
- if (decA.isExactPattern()) {
- world.getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.INCORRECT_TARGET_FOR_DECLARE_ANNOTATION,
- onType.getName(), annoX.stringify(), annoX.getValidTargets()), decA.getSourceLocation()));
+ if (decA.isExactPattern()) {
+ world
+ .getMessageHandler()
+ .handleMessage(
+ MessageUtil
+ .error(
+ WeaverMessages
+ .format(
+ WeaverMessages.INCORRECT_TARGET_FOR_DECLARE_ANNOTATION,
+ onType
+ .getName(),
+ annoX
+ .getTypeName(),
+ annoX
+ .getValidTargets()),
+ decA
+ .getSourceLocation()));
} else {
- if (world.getLint().invalidTargetForAnnotation.isEnabled()) {
- world.getLint().invalidTargetForAnnotation.signal(new String[] { onType.getName(), annoX.stringify(),
- annoX.getValidTargets() }, decA.getSourceLocation(), new ISourceLocation[] { onType
- .getSourceLocation() });
+ if (world.getLint().invalidTargetForAnnotation
+ .isEnabled()) {
+ world.getLint().invalidTargetForAnnotation.signal(
+ new String[] { onType.getName(),
+ annoX.getTypeName(),
+ annoX.getValidTargets() }, decA
+ .getSourceLocation(),
+ new ISourceLocation[] { onType
+ .getSourceLocation() });
}
}
}
for (Iterator j = newParents.iterator(); j.hasNext();) {
ResolvedType newParent = (ResolvedType) j.next();
- // We set it here so that the imminent matching for ITDs can succeed - we
- // still haven't done the necessary changes to the class file itself
- // (like transform super calls) - that is done in BcelTypeMunger.mungeNewParent()
+ // We set it here so that the imminent matching for ITDs can
+ // succeed - we
+ // still haven't done the necessary changes to the class file
+ // itself
+ // (like transform super calls) - that is done in
+ // BcelTypeMunger.mungeNewParent()
classType.addParent(newParent);
- ResolvedTypeMunger newParentMunger = new NewParentTypeMunger(newParent);
+ ResolvedTypeMunger newParentMunger = new NewParentTypeMunger(
+ newParent);
newParentMunger.setSourceLocation(p.getSourceLocation());
- onType.addInterTypeMunger(new BcelTypeMunger(newParentMunger, xcutSet.findAspectDeclaringParents(p)));
+ onType.addInterTypeMunger(new BcelTypeMunger(newParentMunger,
+ xcutSet.findAspectDeclaringParents(p)));
}
}
return didSomething;
}
public void weaveNormalTypeMungers(ResolvedType onType) {
- ContextToken tok = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS, onType
- .getName());
+ ContextToken tok = CompilationAndWeavingContext.enteringPhase(
+ CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS, onType
+ .getName());
if (onType.isRawType() || onType.isParameterizedType())
onType = onType.getGenericType();
for (Iterator i = typeMungerList.iterator(); i.hasNext();) {
}
// exposed for ClassLoader dynamic weaving
- public LazyClassGen weaveWithoutDump(UnwovenClassFile classFile, BcelObjectType classType) throws IOException {
+ public LazyClassGen weaveWithoutDump(UnwovenClassFile classFile,
+ BcelObjectType classType) throws IOException {
return weave(classFile, classType, false);
}
// non-private for testing
- LazyClassGen weave(UnwovenClassFile classFile, BcelObjectType classType) throws IOException {
+ LazyClassGen weave(UnwovenClassFile classFile, BcelObjectType classType)
+ throws IOException {
LazyClassGen ret = weave(classFile, classType, true);
return ret;
}
- private LazyClassGen weave(UnwovenClassFile classFile, BcelObjectType classType, boolean dump) throws IOException {
+ private LazyClassGen weave(UnwovenClassFile classFile,
+ BcelObjectType classType, boolean dump) throws IOException {
if (classType.isSynthetic()) { // Don't touch synthetic classes
if (dump)
dumpUnchanged(classFile);
return null;
}
- List shadowMungers = fastMatch(shadowMungerList, classType.getResolvedTypeX());
+ List shadowMungers = fastMatch(shadowMungerList, classType
+ .getResolvedTypeX());
List typeMungers = classType.getResolvedTypeX().getInterTypeMungers();
classType.getResolvedTypeX().checkInterTypeMungers();
// Decide if we need to do actual weaving for this class
- boolean mightNeedToWeave = shadowMungers.size() > 0 || typeMungers.size() > 0 || classType.isAspect()
- || world.getDeclareAnnotationOnMethods().size() > 0 || world.getDeclareAnnotationOnFields().size() > 0;
-
- // May need bridge methods if on 1.5 and something in our hierarchy is affected by ITDs
- boolean mightNeedBridgeMethods = world.isInJava5Mode() && !classType.isInterface()
- && classType.getResolvedTypeX().getInterTypeMungersIncludingSupers().size() > 0;
+ boolean mightNeedToWeave = shadowMungers.size() > 0
+ || typeMungers.size() > 0 || classType.isAspect()
+ || world.getDeclareAnnotationOnMethods().size() > 0
+ || world.getDeclareAnnotationOnFields().size() > 0;
+
+ // May need bridge methods if on 1.5 and something in our hierarchy is
+ // affected by ITDs
+ boolean mightNeedBridgeMethods = world.isInJava5Mode()
+ && !classType.isInterface()
+ && classType.getResolvedTypeX()
+ .getInterTypeMungersIncludingSupers().size() > 0;
LazyClassGen clazz = null;
if (mightNeedToWeave || mightNeedBridgeMethods) {
clazz = classType.getLazyClassGen();
- // System.err.println("got lazy gen: " + clazz + ", " + clazz.getWeaverState());
+ // System.err.println("got lazy gen: " + clazz + ", " +
+ // clazz.getWeaverState());
try {
boolean isChanged = false;
if (mightNeedToWeave)
- isChanged = BcelClassWeaver.weave(world, clazz, shadowMungers, typeMungers, lateTypeMungerList);
+ isChanged = BcelClassWeaver.weave(world, clazz,
+ shadowMungers, typeMungers, lateTypeMungerList);
if (mightNeedBridgeMethods)
- isChanged = BcelClassWeaver.calculateAnyRequiredBridgeMethods(world, clazz) || isChanged;
+ isChanged = BcelClassWeaver
+ .calculateAnyRequiredBridgeMethods(world, clazz)
+ || isChanged;
if (isChanged) {
if (dump)
classDebugInfo = clazz.getClassName();
}
String messageText = "trouble in: \n" + classDebugInfo;
- getWorld().getMessageHandler().handleMessage(new Message(messageText, IMessage.ABORT, re, null));
+ getWorld().getMessageHandler().handleMessage(
+ new Message(messageText, IMessage.ABORT, re, null));
} catch (Error re) {
String classDebugInfo = null;
try {
classDebugInfo = clazz.getClassName();
}
String messageText = "trouble in: \n" + classDebugInfo;
- getWorld().getMessageHandler().handleMessage(new Message(messageText, IMessage.ABORT, re, null));
+ getWorld().getMessageHandler().handleMessage(
+ new Message(messageText, IMessage.ABORT, re, null));
}
}
dumpUnchanged(classFile);
return clazz;
} else {
- // ATAJ: the class was not weaved, but since it gets there early it may have new generated inner classes
- // attached to it to support LTW perX aspectOf support (see BcelPerClauseAspectAdder)
- // that aggressively defines the inner <aspect>$mayHaveAspect interface.
+ // ATAJ: the class was not weaved, but since it gets there early it
+ // may have new generated inner classes
+ // attached to it to support LTW perX aspectOf support (see
+ // BcelPerClauseAspectAdder)
+ // that aggressively defines the inner <aspect>$mayHaveAspect
+ // interface.
if (clazz != null && !clazz.getChildClasses(world).isEmpty()) {
return clazz;
}
private void dumpUnchanged(UnwovenClassFile classFile) throws IOException {
if (zipOutputStream != null) {
- writeZipEntry(getEntryName(classFile.getJavaClass().getClassName()), classFile.getBytes());
+ writeZipEntry(
+ getEntryName(classFile.getJavaClass().getClassName()),
+ classFile.getBytes());
} else {
classFile.writeUnchangedBytes();
}
return className.replace('.', '/') + ".class";
}
- private void dump(UnwovenClassFile classFile, LazyClassGen clazz) throws IOException {
+ private void dump(UnwovenClassFile classFile, LazyClassGen clazz)
+ throws IOException {
if (zipOutputStream != null) {
String mainClassName = classFile.getJavaClass().getClassName();
- writeZipEntry(getEntryName(mainClassName), clazz.getJavaClass(world).getBytes());
+ writeZipEntry(getEntryName(mainClassName), clazz
+ .getJavaClass(world).getBytes());
if (!clazz.getChildClasses(world).isEmpty()) {
- for (Iterator i = clazz.getChildClasses(world).iterator(); i.hasNext();) {
- UnwovenClassFile.ChildClass c = (UnwovenClassFile.ChildClass) i.next();
- writeZipEntry(getEntryName(mainClassName + "$" + c.name), c.bytes);
+ for (Iterator i = clazz.getChildClasses(world).iterator(); i
+ .hasNext();) {
+ UnwovenClassFile.ChildClass c = (UnwovenClassFile.ChildClass) i
+ .next();
+ writeZipEntry(getEntryName(mainClassName + "$" + c.name),
+ c.bytes);
}
}
} else {
- classFile.writeWovenBytes(clazz.getJavaClass(world).getBytes(), clazz.getChildClasses(world));
+ classFile.writeWovenBytes(clazz.getJavaClass(world).getBytes(),
+ clazz.getChildClasses(world));
}
}
private void writeZipEntry(String name, byte[] bytes) throws IOException {
- ZipEntry newEntry = new ZipEntry(name); // ??? get compression scheme right
+ ZipEntry newEntry = new ZipEntry(name); // ??? get compression scheme
+ // right
zipOutputStream.putNextEntry(newEntry);
zipOutputStream.write(bytes);
return Collections.EMPTY_LIST;
// here we do the coarsest grained fast match with no kind constraints
- // this will remove all obvious non-matches and see if we need to do any weaving
+ // this will remove all obvious non-matches and see if we need to do any
+ // weaving
FastMatchInfo info = new FastMatchInfo(type, null);
List result = new ArrayList();
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.weaver.Advice;
import org.aspectj.weaver.AjAttribute;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationOnTypeMunger;
-import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.ICrossReferenceHandler;
// private ClassPathManager aspectPath = null;
// private List aspectPathEntries;
- private static Trace trace = TraceFactory.getTraceFactory().getTrace(BcelWorld.class);
+ private static Trace trace = TraceFactory.getTraceFactory().getTrace(
+ BcelWorld.class);
// ---- constructors
return ret;
}
- public BcelWorld(List classPath, IMessageHandler handler, ICrossReferenceHandler xrefHandler) {
+ public BcelWorld(List classPath, IMessageHandler handler,
+ ICrossReferenceHandler xrefHandler) {
// this.aspectPath = new ClassPathManager(aspectPath, handler);
this.classPath = new ClassPathManager(classPath, handler);
setMessageHandler(handler);
delegate = this;
}
- public BcelWorld(ClassPathManager cpm, IMessageHandler handler, ICrossReferenceHandler xrefHandler) {
+ public BcelWorld(ClassPathManager cpm, IMessageHandler handler,
+ ICrossReferenceHandler xrefHandler) {
this.classPath = cpm;
setMessageHandler(handler);
setCrossReferenceHandler(xrefHandler);
* @param handler
* @param xrefHandler
*/
- public BcelWorld(ClassLoader loader, IMessageHandler handler, ICrossReferenceHandler xrefHandler) {
+ public BcelWorld(ClassLoader loader, IMessageHandler handler,
+ ICrossReferenceHandler xrefHandler) {
this.classPath = null;
this.loaderRef = new WeakClassLoaderReference(loader);
setMessageHandler(handler);
}
}
- public BcelObjectType buildBcelDelegate(ReferenceType resolvedTypeX, JavaClass jc, boolean exposedToWeaver) {
- BcelObjectType ret = new BcelObjectType(resolvedTypeX, jc, exposedToWeaver);
+ public BcelObjectType buildBcelDelegate(ReferenceType resolvedTypeX,
+ JavaClass jc, boolean exposedToWeaver) {
+ BcelObjectType ret = new BcelObjectType(resolvedTypeX, jc,
+ exposedToWeaver);
return ret;
}
ensureRepositorySetup();
JavaClass jc = delegate.loadClass(name);
if (trace.isTraceEnabled())
- trace.event("lookupJavaClass", this, new Object[] { name, jc });
+ trace.event("lookupJavaClass", this, new Object[] { name,
+ jc });
return jc;
} catch (ClassNotFoundException e) {
if (trace.isTraceEnabled())
- trace.error("Unable to find class '" + name + "' in repository", e);
+ trace.error("Unable to find class '" + name
+ + "' in repository", e);
return null;
}
}
try {
- ClassPathManager.ClassFile file = classPath.find(UnresolvedType.forName(name));
+ ClassPathManager.ClassFile file = classPath.find(UnresolvedType
+ .forName(name));
if (file == null)
return null;
- ClassParser parser = new ClassParser(file.getInputStream(), file.getPath());
+ ClassParser parser = new ClassParser(file.getInputStream(), file
+ .getPath());
JavaClass jc = parser.parse();
file.close();
public BcelObjectType addSourceObjectType(JavaClass jc) {
BcelObjectType ret = null;
- String signature = UnresolvedType.forName(jc.getClassName()).getSignature();
+ String signature = UnresolvedType.forName(jc.getClassName())
+ .getSignature();
Object fromTheMap = typeMap.get(signature);
if (fromTheMap != null && !(fromTheMap instanceof ReferenceType)) {
// what on earth is it then? See pr 112243
StringBuffer exceptionText = new StringBuffer();
- exceptionText.append("Found invalid (not a ReferenceType) entry in the type map. ");
- exceptionText.append("Signature=[" + signature + "] Found=[" + fromTheMap + "] Class=[" + fromTheMap.getClass() + "]");
+ exceptionText
+ .append("Found invalid (not a ReferenceType) entry in the type map. ");
+ exceptionText.append("Signature=[" + signature + "] Found=["
+ + fromTheMap + "] Class=[" + fromTheMap.getClass() + "]");
throw new BCException(exceptionText.toString());
}
if (nameTypeX == null) {
if (jc.isGeneric() && isInJava5Mode()) {
- nameTypeX = ReferenceType.fromTypeX(UnresolvedType.forRawTypeName(jc.getClassName()), this);
+ nameTypeX = ReferenceType.fromTypeX(UnresolvedType
+ .forRawTypeName(jc.getClassName()), this);
ret = buildBcelDelegate(nameTypeX, jc, true);
- ReferenceType genericRefType = new ReferenceType(UnresolvedType.forGenericTypeSignature(signature, ret
- .getDeclaredGenericSignature()), this);
+ ReferenceType genericRefType = new ReferenceType(UnresolvedType
+ .forGenericTypeSignature(signature, ret
+ .getDeclaredGenericSignature()), this);
nameTypeX.setDelegate(ret);
genericRefType.setDelegate(ret);
nameTypeX.setGenericType(genericRefType);
typeMap.remove(ty.getSignature());
}
- public static Member makeFieldJoinPointSignature(LazyClassGen cg, FieldInstruction fi) {
+ public static Member makeFieldJoinPointSignature(LazyClassGen cg,
+ FieldInstruction fi) {
ConstantPool cpg = cg.getConstantPool();
- return MemberImpl.field(fi.getClassName(cpg),
- (fi.opcode == Constants.GETSTATIC || fi.opcode == Constants.PUTSTATIC) ? Modifier.STATIC : 0, fi.getName(cpg), fi
- .getSignature(cpg));
+ return MemberImpl
+ .field(
+ fi.getClassName(cpg),
+ (fi.opcode == Constants.GETSTATIC || fi.opcode == Constants.PUTSTATIC) ? Modifier.STATIC
+ : 0, fi.getName(cpg), fi.getSignature(cpg));
}
- public Member makeJoinPointSignatureFromMethod(LazyMethodGen mg, MemberKind kind) {
+ public Member makeJoinPointSignatureFromMethod(LazyMethodGen mg,
+ MemberKind kind) {
Member ret = mg.getMemberView();
if (ret == null) {
int mods = mg.getAccessFlags();
if (mg.getEnclosingClass().isInterface()) {
mods |= Modifier.INTERFACE;
}
- return new ResolvedMemberImpl(kind, UnresolvedType.forName(mg.getClassName()), mods, fromBcel(mg.getReturnType()), mg
+ return new ResolvedMemberImpl(kind, UnresolvedType.forName(mg
+ .getClassName()), mods, fromBcel(mg.getReturnType()), mg
.getName(), fromBcel(mg.getArgumentTypes()));
} else {
return ret;
}
- public Member makeJoinPointSignatureForMonitorEnter(LazyClassGen cg, InstructionHandle h) {
+ public Member makeJoinPointSignatureForMonitorEnter(LazyClassGen cg,
+ InstructionHandle h) {
return MemberImpl.monitorEnter();
}
- public Member makeJoinPointSignatureForMonitorExit(LazyClassGen cg, InstructionHandle h) {
+ public Member makeJoinPointSignatureForMonitorExit(LazyClassGen cg,
+ InstructionHandle h) {
return MemberImpl.monitorExit();
}
- public Member makeJoinPointSignatureForArrayConstruction(LazyClassGen cg, InstructionHandle handle) {
+ public Member makeJoinPointSignatureForArrayConstruction(LazyClassGen cg,
+ InstructionHandle handle) {
Instruction i = handle.getInstruction();
ConstantPool cpg = cg.getConstantPool();
Member retval = null;
Type ot = i.getType(cpg);
UnresolvedType ut = fromBcel(ot);
ut = UnresolvedType.makeArray(ut, 1);
- retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID, "<init>", new ResolvedType[] { ResolvedType.INT });
+ retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID,
+ "<init>", new ResolvedType[] { ResolvedType.INT });
} else if (i instanceof MULTIANEWARRAY) {
MULTIANEWARRAY arrayInstruction = (MULTIANEWARRAY) i;
UnresolvedType ut = null;
ResolvedType[] parms = new ResolvedType[dimensions];
for (int ii = 0; ii < dimensions; ii++)
parms[ii] = ResolvedType.INT;
- retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID, "<init>", parms);
+ retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID,
+ "<init>", parms);
} else if (i.opcode == Constants.NEWARRAY) {
// NEWARRAY arrayInstruction = (NEWARRAY)i;
Type ot = i.getType();
UnresolvedType ut = fromBcel(ot);
- retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID, "<init>", new ResolvedType[] { ResolvedType.INT });
+ retval = MemberImpl.method(ut, Modifier.PUBLIC, ResolvedType.VOID,
+ "<init>", new ResolvedType[] { ResolvedType.INT });
} else {
- throw new BCException("Cannot create array construction signature for this non-array instruction:" + i);
+ throw new BCException(
+ "Cannot create array construction signature for this non-array instruction:"
+ + i);
}
return retval;
}
- public Member makeJoinPointSignatureForMethodInvocation(LazyClassGen cg, InvokeInstruction ii) {
+ public Member makeJoinPointSignatureForMethodInvocation(LazyClassGen cg,
+ InvokeInstruction ii) {
ConstantPool cpg = cg.getConstantPool();
String name = ii.getName(cpg);
String declaring = ii.getClassName(cpg);
String signature = ii.getSignature(cpg);
int modifier = (ii instanceof INVOKEINTERFACE) ? Modifier.INTERFACE
- : (ii.opcode == Constants.INVOKESTATIC) ? Modifier.STATIC : (ii.opcode == Constants.INVOKESPECIAL && !name
- .equals("<init>")) ? Modifier.PRIVATE : 0;
+ : (ii.opcode == Constants.INVOKESTATIC) ? Modifier.STATIC
+ : (ii.opcode == Constants.INVOKESPECIAL && !name
+ .equals("<init>")) ? Modifier.PRIVATE : 0;
- // in Java 1.4 and after, static method call of super class within subclass method appears
+ // in Java 1.4 and after, static method call of super class within
+ // subclass method appears
// as declared by the subclass in the bytecode - but they are not
// see #104212
if (ii.opcode == Constants.INVOKESTATIC) {
ResolvedType appearsDeclaredBy = resolve(declaring);
// look for the method there
- for (Iterator iterator = appearsDeclaredBy.getMethods(); iterator.hasNext();) {
+ for (Iterator iterator = appearsDeclaredBy.getMethods(); iterator
+ .hasNext();) {
ResolvedMember method = (ResolvedMember) iterator.next();
if (method.isStatic()) {
- if (name.equals(method.getName()) && signature.equals(method.getSignature())) {
+ if (name.equals(method.getName())
+ && signature.equals(method.getSignature())) {
// we found it
declaringType = method.getDeclaringType();
break;
return buf.toString();
}
- public Advice createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature) {
- // System.err.println("concrete advice: " + signature + " context " + sourceContext);
+ public Advice createAdviceMunger(AjAttribute.AdviceAttribute attribute,
+ Pointcut pointcut, Member signature) {
+ // System.err.println("concrete advice: " + signature + " context " +
+ // sourceContext);
return new BcelAdvice(attribute, pointcut, signature, null);
}
- public ConcreteTypeMunger concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType) {
+ public ConcreteTypeMunger concreteTypeMunger(ResolvedTypeMunger munger,
+ ResolvedType aspectType) {
return new BcelTypeMunger(munger, aspectType);
}
return new BcelCflowStackFieldAdder(cflowField);
}
- public ConcreteTypeMunger makeCflowCounterFieldAdder(ResolvedMember cflowField) {
+ public ConcreteTypeMunger makeCflowCounterFieldAdder(
+ ResolvedMember cflowField) {
return new BcelCflowCounterFieldAdder(cflowField);
}
/**
- * Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as needed
+ * Register a munger for perclause @AJ aspect so that we add aspectOf(..) to
+ * them as needed
*
* @param aspect
* @param kind
* @return munger
*/
- public ConcreteTypeMunger makePerClauseAspect(ResolvedType aspect, PerClause.Kind kind) {
+ public ConcreteTypeMunger makePerClauseAspect(ResolvedType aspect,
+ PerClause.Kind kind) {
return new BcelPerClauseAspectAdder(aspect, kind);
}
/**
- * Retrieve a bcel delegate for an aspect - this will return NULL if the delegate is an EclipseSourceType and not a
- * BcelObjectType - this happens quite often when incrementally compiling.
+ * Retrieve a bcel delegate for an aspect - this will return NULL if the
+ * delegate is an EclipseSourceType and not a BcelObjectType - this happens
+ * quite often when incrementally compiling.
*/
public static BcelObjectType getBcelObjectType(ResolvedType concreteAspect) {
- ReferenceTypeDelegate rtDelegate = ((ReferenceType) concreteAspect).getDelegate();
+ ReferenceTypeDelegate rtDelegate = ((ReferenceType) concreteAspect)
+ .getDelegate();
if (rtDelegate instanceof BcelObjectType) {
return (BcelObjectType) rtDelegate;
} else {
}
public void tidyUp() {
- // At end of compile, close any open files so deletion of those archives is possible
+ // At end of compile, close any open files so deletion of those archives
+ // is possible
classPath.closeArchives();
typeMap.report();
ResolvedType.resetPrimitives();
// @Override
/**
- * The aim of this method is to make sure a particular type is 'ok'. Some operations on the delegate for a type modify it and
- * this method is intended to undo that... see pr85132
+ * The aim of this method is to make sure a particular type is 'ok'. Some
+ * operations on the delegate for a type modify it and this method is
+ * intended to undo that... see pr85132
*/
public void validateType(UnresolvedType type) {
ResolvedType result = typeMap.get(type.getSignature());
ReferenceType rt = (ReferenceType) result;
rt.getDelegate().ensureDelegateConsistent();
// If we want to rebuild it 'from scratch' then:
- // ClassParser cp = new ClassParser(new ByteArrayInputStream(newbytes),new String(cs));
+ // ClassParser cp = new ClassParser(new
+ // ByteArrayInputStream(newbytes),new String(cs));
// try {
// rt.setDelegate(makeBcelObjectType(rt,cp.parse(),true));
// } catch (ClassFormatException e) {
for (Iterator j = newParents.iterator(); j.hasNext();) {
ResolvedType newParent = (ResolvedType) j.next();
- // We set it here so that the imminent matching for ITDs can succeed - we
- // still haven't done the necessary changes to the class file itself
- // (like transform super calls) - that is done in BcelTypeMunger.mungeNewParent()
+ // We set it here so that the imminent matching for ITDs can
+ // succeed - we
+ // still haven't done the necessary changes to the class file
+ // itself
+ // (like transform super calls) - that is done in
+ // BcelTypeMunger.mungeNewParent()
classType.addParent(newParent);
- ResolvedTypeMunger newParentMunger = new NewParentTypeMunger(newParent);
+ ResolvedTypeMunger newParentMunger = new NewParentTypeMunger(
+ newParent);
newParentMunger.setSourceLocation(p.getSourceLocation());
- onType.addInterTypeMunger(new BcelTypeMunger(newParentMunger, getCrosscuttingMembersSet()
- .findAspectDeclaringParents(p)));
+ onType.addInterTypeMunger(new BcelTypeMunger(newParentMunger,
+ getCrosscuttingMembersSet().findAspectDeclaringParents(
+ p)));
}
}
return didSomething;
/**
* Apply a declare @type - return true if we change the type
*/
- private boolean applyDeclareAtType(DeclareAnnotation decA, ResolvedType onType, boolean reportProblems) {
+ private boolean applyDeclareAtType(DeclareAnnotation decA,
+ ResolvedType onType, boolean reportProblems) {
boolean didSomething = false;
if (decA.matches(onType)) {
- if (onType.hasAnnotation(decA.getAnnotationX().getSignature())) {
+ if (onType.hasAnnotation(decA.getAnnotationX().getType())) {
// already has it
return false;
}
- AnnotationX annoX = decA.getAnnotationX();
+ AnnotationAJ annoX = decA.getAnnotationX();
// check the annotation is suitable for the target
boolean isOK = checkTargetOK(decA, onType, annoX);
if (isOK) {
didSomething = true;
- ResolvedTypeMunger newAnnotationTM = new AnnotationOnTypeMunger(annoX);
+ ResolvedTypeMunger newAnnotationTM = new AnnotationOnTypeMunger(
+ annoX);
newAnnotationTM.setSourceLocation(decA.getSourceLocation());
- onType.addInterTypeMunger(new BcelTypeMunger(newAnnotationTM, decA.getAspect().resolve(this)));
+ onType.addInterTypeMunger(new BcelTypeMunger(newAnnotationTM,
+ decA.getAspect().resolve(this)));
decA.copyAnnotationTo(onType);
}
}
}
/**
- * Checks for an @target() on the annotation and if found ensures it allows the annotation to be attached to the target type
- * that matched.
+ * Checks for an @target() on the annotation and if found ensures it allows
+ * the annotation to be attached to the target type that matched.
*/
- private boolean checkTargetOK(DeclareAnnotation decA, ResolvedType onType, AnnotationX annoX) {
+ private boolean checkTargetOK(DeclareAnnotation decA, ResolvedType onType,
+ AnnotationAJ annoX) {
if (annoX.specifiesTarget()) {
- if ((onType.isAnnotation() && !annoX.allowedOnAnnotationType()) || (!annoX.allowedOnRegularType())) {
+ if ((onType.isAnnotation() && !annoX.allowedOnAnnotationType())
+ || (!annoX.allowedOnRegularType())) {
return false;
}
}
return true;
}
- // Hmmm - very similar to the code in BcelWeaver.weaveParentTypeMungers - this code
- // doesn't need to produce errors/warnings though as it won't really be weaving.
+ // Hmmm - very similar to the code in BcelWeaver.weaveParentTypeMungers -
+ // this code
+ // doesn't need to produce errors/warnings though as it won't really be
+ // weaving.
protected void weaveInterTypeDeclarations(ResolvedType onType) {
- List declareParentsList = getCrosscuttingMembersSet().getDeclareParents();
+ List declareParentsList = getCrosscuttingMembersSet()
+ .getDeclareParents();
if (onType.isRawType())
onType = onType.getGenericType();
onType.clearInterTypeMungers();
boolean typeChanged = applyDeclareParents(decp, onType);
if (typeChanged) {
aParentChangeOccurred = true;
- } else { // Perhaps it would have matched if a 'dec @type' had modified the type
+ } else { // Perhaps it would have matched if a 'dec @type' had
+ // modified the type
if (!decp.getChild().isStarAnnotation())
decpToRepeat.add(decp);
}
}
// Still first pass - apply all dec @type mungers
- for (Iterator i = getCrosscuttingMembersSet().getDeclareAnnotationOnTypes().iterator(); i.hasNext();) {
+ for (Iterator i = getCrosscuttingMembersSet()
+ .getDeclareAnnotationOnTypes().iterator(); i.hasNext();) {
DeclareAnnotation decA = (DeclareAnnotation) i.next();
boolean typeChanged = applyDeclareAtType(decA, onType, true);
if (typeChanged) {
}
}
- while ((aParentChangeOccurred || anAnnotationChangeOccurred) && !decpToRepeat.isEmpty()) {
+ while ((aParentChangeOccurred || anAnnotationChangeOccurred)
+ && !decpToRepeat.isEmpty()) {
anAnnotationChangeOccurred = aParentChangeOccurred = false;
List decpToRepeatNextTime = new ArrayList();
for (Iterator iter = decpToRepeat.iterator(); iter.hasNext();) {
}
}
- for (Iterator iter = getCrosscuttingMembersSet().getDeclareAnnotationOnTypes().iterator(); iter.hasNext();) {
+ for (Iterator iter = getCrosscuttingMembersSet()
+ .getDeclareAnnotationOnTypes().iterator(); iter.hasNext();) {
DeclareAnnotation decA = (DeclareAnnotation) iter.next();
boolean typeChanged = applyDeclareAtType(decA, onType, false);
if (typeChanged) {
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.weaver.AjAttribute;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.MemberImpl;
public LazyMethodGen(int accessFlags, Type returnType, String name, Type[] paramTypes, String[] declaredExceptions,
LazyClassGen enclosingClass) {
- // System.err.println("raw create of: " + name + ", " + enclosingClass.getName() + ", " + returnType);
- this.memberView = null; // ??? should be okay, since constructed ones aren't woven into
+ // System.err.println("raw create of: " + name + ", " +
+ // enclosingClass.getName() + ", " + returnType);
+ this.memberView = null; // ??? should be okay, since constructed ones
+ // aren't woven into
this.accessFlags = accessFlags;
this.returnType = returnType;
this.name = name;
// @AJ advice are not inlined by default since requires further analysis
// and weaving ordering control
- // TODO AV - improve - note: no room for improvement as long as aspects are reweavable
- // since the inlined version with wrappers and an to be done annotation to keep
+ // TODO AV - improve - note: no room for improvement as long as aspects
+ // are reweavable
+ // since the inlined version with wrappers and an to be done annotation
+ // to keep
// inline state will be garbaged due to reweavable impl
if (memberView != null && isAdviceMethod()) {
if (enclosingClass.getType().isAnnotationStyleAspect()) {
private Method savedMethod = null;
- // build from an existing method, lazy build saves most work for initialization
+ // build from an existing method, lazy build saves most work for
+ // initialization
public LazyMethodGen(Method m, LazyClassGen enclosingClass) {
savedMethod = m;
// @AJ advice are not inlined by default since requires further analysis
// and weaving ordering control
- // TODO AV - improve - note: no room for improvement as long as aspects are reweavable
- // since the inlined version with wrappers and an to be done annotation to keep
+ // TODO AV - improve - note: no room for improvement as long as aspects
+ // are reweavable
+ // since the inlined version with wrappers and an to be done annotation
+ // to keep
// inline state will be garbaged due to reweavable impl
if (memberView != null && isAdviceMethod()) {
if (enclosingClass.getType().isAnnotationStyleAspect()) {
if ((m.isAbstract() || m.isNative()) && savedMethod.getCode() != null) {
throw new RuntimeException("bad abstract method with code: " + m + " on " + enclosingClass);
}
- // this.memberView = new BcelMethod(enclosingClass.getBcelObjectType(), m);
+ // this.memberView = new BcelMethod(enclosingClass.getBcelObjectType(),
+ // m);
this.memberView = m;
this.accessFlags = savedMethod.getModifiers();
this.name = m.getName();
// @AJ advice are not inlined by default since requires further analysis
// and weaving ordering control
- // TODO AV - improve - note: no room for improvement as long as aspects are reweavable
- // since the inlined version with wrappers and an to be done annotation to keep
+ // TODO AV - improve - note: no room for improvement as long as aspects
+ // are reweavable
+ // since the inlined version with wrappers and an to be done annotation
+ // to keep
// inline state will be garbaged due to reweavable impl
if (memberView != null && isAdviceMethod()) {
if (enclosingClass.getType().isAnnotationStyleAspect()) {
}
}
- public void addAnnotation(AnnotationX ax) {
+ public void addAnnotation(AnnotationAJ ax) {
initialize();
if (memberView == null) {
// If member view is null, we manage them in newAnnotations
// Check local annotations first
if (newAnnotations != null) {
for (Iterator iter = newAnnotations.iterator(); iter.hasNext();) {
- AnnotationX element = (AnnotationX) iter.next();
- if (element.getBcelAnnotation().getTypeName().equals(annotationTypeX.getName()))
+ AnnotationAJ element = (AnnotationAJ) iter.next();
+ if (element.getTypeSignature().equals(annotationTypeX.getSignature())) {
return true;
+ }
}
}
memberView = new BcelMethod(getEnclosingClass().getBcelObjectType(), getMethod());
if (returnType != null)
return;
- // System.err.println("initializing: " + getName() + ", " + enclosingClass.getName() + ", " + returnType + ", " +
+ // System.err.println("initializing: " + getName() + ", " +
+ // enclosingClass.getName() + ", " + returnType + ", " +
// savedMethod);
MethodGen gen = new MethodGen(savedMethod, enclosingClass.getName(), enclosingClass.getConstantPool(), true);
this.maxLocals = gen.getMaxLocals();
// this.returnType = BcelWorld.makeBcelType(memberView.getReturnType());
- // this.argumentTypes = BcelWorld.makeBcelTypes(memberView.getParameterTypes());
+ // this.argumentTypes =
+ // BcelWorld.makeBcelTypes(memberView.getParameterTypes());
//
- // this.declaredExceptions = UnresolvedType.getNames(memberView.getExceptions()); //gen.getExceptions();
+ // this.declaredExceptions =
+ // UnresolvedType.getNames(memberView.getExceptions());
+ // //gen.getExceptions();
// this.attributes = new Attribute[0]; //gen.getAttributes();
// this.maxLocals = savedMethod.getCode().getMaxLocals();
}
assertGoodBody();
- // System.err.println("initialized: " + this.getClassName() + "." + this.getName());
+ // System.err.println("initialized: " + this.getClassName() + "." +
+ // this.getName());
}
- // XXX we're relying on the javac promise I've just made up that we won't have an early exception
+ // XXX we're relying on the javac promise I've just made up that we won't
+ // have an early exception
// in the list mask a later exception: That is, for two exceptions E and F,
- // if E preceeds F, then either E \cup F = {}, or E \nonstrictsubset F. So when we add F,
- // we add it on the _OUTSIDE_ of any handlers that share starts or ends with it.
+ // if E preceeds F, then either E \cup F = {}, or E \nonstrictsubset F. So
+ // when we add F,
+ // we add it on the _OUTSIDE_ of any handlers that share starts or ends with
+ // it.
// with that in mind, we merrily go adding ranges for exceptions.
public Method getMethod() {
if (savedMethod != null)
- return savedMethod; // ??? this relies on gentle treatment of constant pool
+ return savedMethod; // ??? this relies on gentle treatment of
+ // constant pool
try {
MethodGen gen = pack();
IMessage.ERROR,
WeaverMessages.format(WeaverMessages.PROBLEM_GENERATING_METHOD, this.getClassName(), this.getName(), e
.getMessage()), this.getMemberView() == null ? null : this.getMemberView().getSourceLocation(), null);
- // throw e; PR 70201.... let the normal problem reporting infrastructure deal with this rather than crashing.
+ // throw e; PR 70201.... let the normal problem reporting
+ // infrastructure deal with this rather than crashing.
body = null;
MethodGen gen = pack();
return gen.getMethod();
List as = Utility.readAjAttributes(getClassName(), (Attribute[]) attributes.toArray(new Attribute[] {}), context, null,
weaverVersion);
if (!as.isEmpty()) {
- out.println(" " + as.get(0)); // XXX assuming exactly one attribute, munger...
+ out.println(" " + as.get(0)); // XXX assuming exactly one
+ // attribute, munger...
}
}
for (InstructionHandle ih = body.getStart(); ih != null; ih = ih.getNext()) {
Iterator tIter = ih.getTargeters().iterator();
while (tIter.hasNext()) {
- InstructionTargeter t = (InstructionTargeter) tIter.next();// targeters[i];
+ InstructionTargeter t = (InstructionTargeter) tIter.next();// targeters
+ // [
+ // i
+ // ]
+ // ;
if (t instanceof ExceptionRange) {
// assert isRangeHandle(h);
ExceptionRange r = (ExceptionRange) t;
bodyPrint: for (InstructionHandle ih = body.getStart(); ih != null; ih = ih.getNext()) {
if (Range.isRangeHandle(ih)) {
Range r = Range.getRange(ih);
- // don't print empty ranges, that is, ranges who contain no actual instructions
+ // don't print empty ranges, that is, ranges who contain no
+ // actual instructions
for (InstructionHandle xx = r.getStart(); Range.isRangeHandle(xx); xx = xx.getNext()) {
if (xx == r.getEnd())
continue bodyPrint;
}
- // doesn't handle nested: if (r.getStart().getNext() == r.getEnd()) continue;
+ // doesn't handle nested: if (r.getStart().getNext() ==
+ // r.getEnd()) continue;
if (r.getStart() == ih) {
printRangeString(r, depth++);
} else {
out.print(" ");
out.print(labelMap.get(brinst.getTarget()));
} else if (inst.isLocalVariableInstruction()) {
- // LocalVariableInstruction lvinst = (LocalVariableInstruction) inst;
+ // LocalVariableInstruction lvinst = (LocalVariableInstruction)
+ // inst;
out.print(inst.toString(false).toUpperCase());
int index = inst.getIndex();
LocalVariableTag tag = getLocalVariableTag(h, index);
if (newAnnotations != null) {
for (Iterator iter = newAnnotations.iterator(); iter.hasNext();) {
- AnnotationX element = (AnnotationX) iter.next();
- gen.addAnnotation(new AnnotationGen(element.getBcelAnnotation(), gen.getConstantPool(), true));
+ AnnotationAJ element = (AnnotationAJ) iter.next();
+ gen.addAnnotation(new AnnotationGen(((BcelAnnotation)element).getBcelAnnotation(), gen.getConstantPool(), true));
}
}
if (memberView != null && memberView.getAnnotations() != null && memberView.getAnnotations().length != 0) {
- AnnotationX[] ans = memberView.getAnnotations();
+ AnnotationAJ[] ans = memberView.getAnnotations();
for (int i = 0, len = ans.length; i < len; i++) {
- AnnotationGen a = ans[i].getBcelAnnotation();
+ AnnotationGen a = ((BcelAnnotation) ans[i]).getBcelAnnotation();
gen.addAnnotation(new AnnotationGen(a, gen.getConstantPool(), true));
}
}
if (enclosingClass.getWorld().isInJava5Mode()) {
gen.setModifiers(gen.getModifiers() | ACC_SYNTHETIC);
}
- // belt and braces, do the attribute even on Java 5 in addition to the modifier flag
+ // belt and braces, do the attribute even on Java 5 in addition to
+ // the modifier flag
ConstantPool cpg = gen.getConstantPool();
int index = cpg.addUtf8("Synthetic");
gen.addAttribute(new Synthetic(index, 0, new byte[0], cpg));
while (oldInstructionHandle != null) {
if (map.get(oldInstructionHandle) == null) {
- // must be a range instruction since they're the only things we didn't copy across
+ // must be a range instruction since they're the only things we
+ // didn't copy across
handleRangeInstruction(oldInstructionHandle, exceptionList);
// just increment ih.
oldInstructionHandle = oldInstructionHandle.getNext();
} else if (targeter instanceof LocalVariableTag) {
LocalVariableTag lvt = (LocalVariableTag) targeter;
LVPosition p = (LVPosition) localVariables.get(lvt);
- // If we don't know about it, create a new position and store
+ // If we don't know about it, create a new position and
+ // store
// If we do know about it - update its end position
if (p == null) {
LVPosition newp = new LVPosition();
addExceptionHandlers(gen, map, exceptionList);
addLocalVariables(gen, localVariables);
- // JAVAC adds line number tables (with just one entry) to generated accessor methods - this
- // keeps some tools that rely on finding at least some form of linenumbertable happy.
+ // JAVAC adds line number tables (with just one entry) to generated
+ // accessor methods - this
+ // keeps some tools that rely on finding at least some form of
+ // linenumbertable happy.
// Let's check if we have one - if we don't then let's add one.
- // TODO Could be made conditional on whether line debug info is being produced
+ // TODO Could be made conditional on whether line debug info is being
+ // produced
if (gen.getLineNumbers().length == 0) {
gen.addLineNumber(gen.getInstructionList().getStart(), 1);
}
LinkedList exceptionList = new LinkedList();
Set forDeletion = new HashSet();
Set branchInstructions = new HashSet();
- // OPTIMIZE sort out in here: getRange()/insertHandler() and type of exceptionList
+ // OPTIMIZE sort out in here: getRange()/insertHandler() and type of
+ // exceptionList
while (iHandle != null) {
Instruction inst = iHandle.getInstruction();
// InstructionHandle nextInst = iHandle.getNext();
- // OPTIMIZE remove this instructionhandle as it now points to nowhere?
+ // OPTIMIZE remove this instructionhandle as it now points to
+ // nowhere?
if (inst == Range.RANGEINSTRUCTION) {
Range r = Range.getRange(iHandle);
if (r instanceof ExceptionRange) {
ExceptionRange er = (ExceptionRange) r;
if (er.getStart() == iHandle) {
if (!er.isEmpty()) {
- // order is important, insert handlers in order of start
+ // order is important, insert handlers in order of
+ // start
insertHandler(er, exceptionList);
}
}
} else if (targeter instanceof LocalVariableTag) {
LocalVariableTag lvt = (LocalVariableTag) targeter;
LVPosition p = (LVPosition) localVariables.get(lvt);
- // If we don't know about it, create a new position and store
+ // If we don't know about it, create a new position
+ // and store
// If we do know about it - update its end position
if (p == null) {
LVPosition newp = new LVPosition();
gen.setInstructionList(theBody);
addLocalVariables(gen, localVariables);
- // JAVAC adds line number tables (with just one entry) to generated accessor methods - this
- // keeps some tools that rely on finding at least some form of linenumbertable happy.
+ // JAVAC adds line number tables (with just one entry) to generated
+ // accessor methods - this
+ // keeps some tools that rely on finding at least some form of
+ // linenumbertable happy.
// Let's check if we have one - if we don't then let's add one.
- // TODO Could be made conditional on whether line debug info is being produced
+ // TODO Could be made conditional on whether line debug info is being
+ // produced
if (gen.getLineNumbers().length == 0) {
gen.addLineNumber(gen.getInstructionList().getStart(), 1);
}
Map duplicatedLocalMap = new HashMap();
for (Iterator iter = localVariables.keySet().iterator(); iter.hasNext();) {
LocalVariableTag tag = (LocalVariableTag) iter.next();
- // have we already added one with the same slot number and start location?
+ // have we already added one with the same slot number and start
+ // location?
// if so, just continue.
LVPosition lvpos = (LVPosition) localVariables.get(tag);
InstructionHandle start = lvpos.start;
private void handleBranchInstruction(Map map, Instruction oldInstruction, Instruction newInstruction) {
InstructionBranch oldBranchInstruction = (InstructionBranch) oldInstruction;
InstructionBranch newBranchInstruction = (InstructionBranch) newInstruction;
- InstructionHandle oldTarget = oldBranchInstruction.getTarget(); // old target
+ InstructionHandle oldTarget = oldBranchInstruction.getTarget(); // old
+ // target
// New target is in hash map
newBranchInstruction.setTarget(remap(oldTarget, map));
// block (pr78021,pr79554).
// exception ordering.
- // What we should be doing is dealing with priority inversions way earlier than we are
- // and counting on the tree structure. In which case, the below code is in fact right.
+ // What we should be doing is dealing with priority inversions way earlier
+ // than we are
+ // and counting on the tree structure. In which case, the below code is in
+ // fact right.
// XXX THIS COMMENT BELOW IS CURRENTLY WRONG.
// An exception A preceeds an exception B in the exception table iff:
- // * A and B were in the original method, and A preceeded B in the original exception table
+ // * A and B were in the original method, and A preceeded B in the original
+ // exception table
// * If A has a higher priority than B, than it preceeds B.
- // * If A and B have the same priority, then the one whose START happens EARLIEST has LEAST priority.
+ // * If A and B have the same priority, then the one whose START happens
+ // EARLIEST has LEAST priority.
// in short, the outermost exception has least priority.
- // we implement this with a LinkedList. We could possibly implement this with a java.util.SortedSet,
- // but I don't trust the only implementation, TreeSet, to do the right thing.
+ // we implement this with a LinkedList. We could possibly implement this
+ // with a java.util.SortedSet,
+ // but I don't trust the only implementation, TreeSet, to do the right
+ // thing.
/* private */static void insertHandler(ExceptionRange fresh, LinkedList l) {
// Old implementation, simply: l.add(0,fresh);
public void assertGoodBody() {
if (true)
- return; // only enable for debugging, consider using cheaper toString()
- assertGoodBody(getBody(), toString()); // definingType.getNameAsIdentifier() + "." + getName()); //toString());
+ return; // only enable for debugging, consider using cheaper
+ // toString()
+ assertGoodBody(getBody(), toString()); // definingType.getNameAsIdentifier
+ // () + "." + getName());
+ // //toString());
}
public static void assertGoodBody(InstructionList il, String from) {
import org.aspectj.apache.bcel.generic.Type;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.weaver.AjAttribute;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.Lint;
if (isl == null || isl.getSourceFile() == null || isl.getSourceFile().getName().indexOf("no debug info available") != -1) {
nice.append("no debug info available");
} else {
- // can't use File.getName() as this fails when a Linux box encounters a path created on Windows and vice-versa
+ // can't use File.getName() as this fails when a Linux box
+ // encounters a path created on Windows and vice-versa
int takeFrom = isl.getSourceFile().getPath().lastIndexOf('/');
if (takeFrom == -1) {
takeFrom = isl.getSourceFile().getPath().lastIndexOf('\\');
private static String[] argNames = new String[] { "arg0", "arg1", "arg2", "arg3", "arg4" };
- // ??? these should perhaps be cached. Remember to profile this to see if it's a problem.
+ // ??? these should perhaps be cached. Remember to profile this to see if
+ // it's a problem.
public static String[] makeArgNames(int n) {
String[] ret = new String[n];
for (int i = 0; i < n; i++) {
if (!toType.isConvertableFrom(fromType) && !fromType.isConvertableFrom(toType)) {
throw new BCException("can't convert from " + fromType + " to " + toType);
}
- // XXX I'm sure this test can be simpler but my brain hurts and this works
+ // XXX I'm sure this test can be simpler but my brain hurts and this
+ // works
if (!toType.getWorld().isInJava5Mode()) {
if (toType.needsNoConversionFrom(fromType))
return;
il.append(fact.createInvoke("org.aspectj.runtime.internal.Conversions", name, Type.OBJECT, new Type[] { from },
Constants.INVOKESTATIC));
} else if (toType.getWorld().isInJava5Mode() && validBoxing.get(toType.getSignature() + fromType.getSignature()) != null) {
- // XXX could optimize by using any java boxing code that may be just before the call...
+ // XXX could optimize by using any java boxing code that may be just
+ // before the call...
Type from = BcelWorld.makeBcelType(fromType);
Type to = BcelWorld.makeBcelType(toType);
String name = (String) validBoxing.get(toType.getSignature() + fromType.getSignature());
}
/** returns -1 if no source line attribute */
- // this naive version overruns the JVM stack size, if only Java understood tail recursion...
+ // this naive version overruns the JVM stack size, if only Java understood
+ // tail recursion...
// public static int getSourceLine(InstructionHandle ih) {
// if (ih == null) return -1;
//
// }
// return getSourceLine(ih.getNext());
// }
- public static int getSourceLine(InstructionHandle ih) {// ,boolean goforwards) {
+ public static int getSourceLine(InstructionHandle ih) {// ,boolean
+ // goforwards) {
int lookahead = 0;
- // arbitrary rule that we will never lookahead more than 100 instructions for a line #
+ // arbitrary rule that we will never lookahead more than 100
+ // instructions for a line #
while (lookahead++ < 100) {
if (ih == null)
return -1;
// return getSourceLine(ih,false);
// }
- // assumes that there is no already extant source line tag. Otherwise we'll have to be better.
+ // assumes that there is no already extant source line tag. Otherwise we'll
+ // have to be better.
public static void setSourceLine(InstructionHandle ih, int lineNumber) {
- // OPTIMIZE LineNumberTag instances for the same line could be shared throughout a method...
+ // OPTIMIZE LineNumberTag instances for the same line could be shared
+ // throughout a method...
ih.addTargeter(new LineNumberTag(lineNumber));
}
* (identified by its key) should be ignored.
*
*/
- public static boolean isSuppressing(AnnotationX[] anns, String lintkey) {
+ public static boolean isSuppressing(AnnotationAJ[] anns, String lintkey) {
if (anns == null)
return false;
boolean suppressed = false;
// Go through the annotation types on the advice
for (int i = 0; !suppressed && i < anns.length; i++) {
// Check for the SuppressAjWarnings annotation
- if (UnresolvedType.SUPPRESS_AJ_WARNINGS.getSignature().equals(anns[i].getBcelAnnotation().getTypeSignature())) {
+ if (UnresolvedType.SUPPRESS_AJ_WARNINGS.getSignature().equals(anns[i].getTypeSignature())) {
// Two possibilities:
// 1. there are no values specified (i.e. @SuppressAjWarnings)
- // 2. there are values specified (i.e. @SuppressAjWarnings("A") or @SuppressAjWarnings({"A","B"})
- List vals = anns[i].getBcelAnnotation().getValues();
+ // 2. there are values specified (i.e. @SuppressAjWarnings("A")
+ // or @SuppressAjWarnings({"A","B"})
+ List vals = ((BcelAnnotation) anns[i]).getBcelAnnotation().getValues();
if (vals == null || vals.isEmpty()) { // (1)
suppressed = true;
} else { // (2)
return suppressed;
}
- public static List/* Lint.Kind */getSuppressedWarnings(AnnotationX[] anns, Lint lint) {
+ public static List/* Lint.Kind */getSuppressedWarnings(AnnotationAJ[] anns, Lint lint) {
if (anns == null)
return Collections.EMPTY_LIST;
// Go through the annotation types
boolean found = false;
for (int i = 0; !found && i < anns.length; i++) {
// Check for the SuppressAjWarnings annotation
- if (UnresolvedType.SUPPRESS_AJ_WARNINGS.getSignature().equals(anns[i].getBcelAnnotation().getTypeSignature())) {
+ if (UnresolvedType.SUPPRESS_AJ_WARNINGS.getSignature().equals(
+ ((BcelAnnotation) anns[i]).getBcelAnnotation().getTypeSignature())) {
found = true;
// Two possibilities:
// 1. there are no values specified (i.e. @SuppressAjWarnings)
- // 2. there are values specified (i.e. @SuppressAjWarnings("A") or @SuppressAjWarnings({"A","B"})
- List vals = anns[i].getBcelAnnotation().getValues();
+ // 2. there are values specified (i.e. @SuppressAjWarnings("A")
+ // or @SuppressAjWarnings({"A","B"})
+ List vals = ((BcelAnnotation) anns[i]).getBcelAnnotation().getValues();
if (vals == null || vals.isEmpty()) { // (1)
suppressedWarnings.addAll(lint.allKinds());
} else { // (2)
// public static boolean isSimple(Method method) {
// if (method.getCode()==null) return true;
// if (method.getCode().getCode().length>10) return false;
- // InstructionList instrucs = new InstructionList(method.getCode().getCode()); // expensive!
+ // InstructionList instrucs = new
+ // InstructionList(method.getCode().getCode()); // expensive!
// InstructionHandle InstrHandle = instrucs.getStart();
// while (InstrHandle != null) {
// Instruction Instr = InstrHandle.getInstruction();
// int opCode = Instr.opcode;
- // // if current instruction is a branch instruction, see if it's a backward branch.
+ // // if current instruction is a branch instruction, see if it's a backward
+ // branch.
// // if it is return immediately (can't be trivial)
// if (Instr instanceof InstructionBranch) {
// // InstructionBranch BI = (InstructionBranch) Instr;
// if (Instr.getIndex() < 0) return false;
// } else if (Instr instanceof InvokeInstruction) {
- // // if current instruction is an invocation, indicate that it can't be trivial
+ // // if current instruction is an invocation, indicate that it can't be
+ // trivial
// return false;
// }
// InstrHandle = InstrHandle.getNext();
import java.util.Map;
import org.aspectj.bridge.MessageUtil;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.World;
public class DeclareAnnotation extends Declare {
-
- public static final Kind AT_TYPE = new Kind(1,"type");
- public static final Kind AT_FIELD = new Kind(2,"field");
- public static final Kind AT_METHOD = new Kind(3,"method");
- public static final Kind AT_CONSTRUCTOR = new Kind(4,"constructor");
-
+
+ public static final Kind AT_TYPE = new Kind(1, "type");
+ public static final Kind AT_FIELD = new Kind(2, "field");
+ public static final Kind AT_METHOD = new Kind(3, "method");
+ public static final Kind AT_CONSTRUCTOR = new Kind(4, "constructor");
+
private Kind kind;
- private TypePattern typePattern; // for declare @type
- private SignaturePattern sigPattern; // for declare @field,@method,@constructor
+ private TypePattern typePattern; // for declare @type
+ private SignaturePattern sigPattern; // for declare
+ // @field,@method,@constructor
private String annotationMethod = "unknown";
private String annotationString = "@<annotation>";
private ResolvedType containingAspect;
- private AnnotationX annotation;
-
- /**
- * Captures type of declare annotation (method/type/field/constructor)
- */
+ private AnnotationAJ annotation;
+
+ /**
+ * Captures type of declare annotation (method/type/field/constructor)
+ */
public static class Kind {
private final int id;
private String s;
-
- private Kind(int n,String name) {
+
+ private Kind(int n, String name) {
id = n;
s = name;
}
-
+
public int hashCode() {
- return (19 + 37*id);
+ return (19 + 37 * id);
}
- public boolean equals(Object obj) {
- if (!(obj instanceof Kind)) return false;
- Kind other = (Kind) obj;
- return other.id == id;
- }
-
- public String toString() {
- return "at_"+s;
- }
- }
+ public boolean equals(Object obj) {
+ if (!(obj instanceof Kind))
+ return false;
+ Kind other = (Kind) obj;
+ return other.id == id;
+ }
-
+ public String toString() {
+ return "at_" + s;
+ }
+ }
public DeclareAnnotation(Kind kind, TypePattern typePattern) {
this.typePattern = typePattern;
this.kind = kind;
}
-
- /**
- * Returns the string, useful before the real annotation has been resolved
- */
- public String getAnnotationString() { return annotationString;}
-
+
+ /**
+ * Returns the string, useful before the real annotation has been resolved
+ */
+ public String getAnnotationString() {
+ return annotationString;
+ }
+
public DeclareAnnotation(Kind kind, SignaturePattern sigPattern) {
this.sigPattern = sigPattern;
this.kind = kind;
}
-
+
public boolean isExactPattern() {
return typePattern instanceof ExactTypePattern;
}
-
- public String getAnnotationMethod() { return annotationMethod;}
-
+
+ public String getAnnotationMethod() {
+ return annotationMethod;
+ }
+
public String toString() {
StringBuffer ret = new StringBuffer();
ret.append("declare @");
ret.append(kind);
ret.append(" : ");
- ret.append(typePattern != null ? typePattern.toString() : sigPattern.toString());
+ ret.append(typePattern != null ? typePattern.toString() : sigPattern
+ .toString());
ret.append(" : ");
ret.append(annotationString);
return ret.toString();
}
-
+
public Object accept(PatternNodeVisitor visitor, Object data) {
- return visitor.visit(this,data);
+ return visitor.visit(this, data);
}
-
+
public void resolve(IScope scope) {
if (!scope.getWorld().isInJava5Mode()) {
String msg = null;
- if (kind == AT_TYPE) { msg = WeaverMessages.DECLARE_ATTYPE_ONLY_SUPPORTED_AT_JAVA5_LEVEL; }
- else if (kind == AT_METHOD) { msg = WeaverMessages.DECLARE_ATMETHOD_ONLY_SUPPORTED_AT_JAVA5_LEVEL;}
- else if (kind == AT_FIELD) { msg = WeaverMessages.DECLARE_ATFIELD_ONLY_SUPPORTED_AT_JAVA5_LEVEL;}
- else if (kind == AT_CONSTRUCTOR) { msg = WeaverMessages.DECLARE_ATCONS_ONLY_SUPPORTED_AT_JAVA5_LEVEL;}
+ if (kind == AT_TYPE) {
+ msg = WeaverMessages.DECLARE_ATTYPE_ONLY_SUPPORTED_AT_JAVA5_LEVEL;
+ } else if (kind == AT_METHOD) {
+ msg = WeaverMessages.DECLARE_ATMETHOD_ONLY_SUPPORTED_AT_JAVA5_LEVEL;
+ } else if (kind == AT_FIELD) {
+ msg = WeaverMessages.DECLARE_ATFIELD_ONLY_SUPPORTED_AT_JAVA5_LEVEL;
+ } else if (kind == AT_CONSTRUCTOR) {
+ msg = WeaverMessages.DECLARE_ATCONS_ONLY_SUPPORTED_AT_JAVA5_LEVEL;
+ }
scope.message(MessageUtil.error(WeaverMessages.format(msg),
getSourceLocation()));
return;
}
if (typePattern != null) {
- typePattern = typePattern.resolveBindings(scope,Bindings.NONE,false,false);
+ typePattern = typePattern.resolveBindings(scope, Bindings.NONE,
+ false, false);
}
if (sigPattern != null) {
- sigPattern = sigPattern.resolveBindings(scope,Bindings.NONE);
+ sigPattern = sigPattern.resolveBindings(scope, Bindings.NONE);
}
this.containingAspect = scope.getEnclosingType();
}
- public Declare parameterizeWith(Map typeVariableBindingMap,World w) {
+ public Declare parameterizeWith(Map typeVariableBindingMap, World w) {
DeclareAnnotation ret;
if (this.kind == AT_TYPE) {
- ret = new DeclareAnnotation(kind,this.typePattern.parameterizeWith(typeVariableBindingMap,w));
+ ret = new DeclareAnnotation(kind, this.typePattern
+ .parameterizeWith(typeVariableBindingMap, w));
} else {
- ret = new DeclareAnnotation(kind, this.sigPattern.parameterizeWith(typeVariableBindingMap,w));
+ ret = new DeclareAnnotation(kind, this.sigPattern.parameterizeWith(
+ typeVariableBindingMap, w));
}
ret.annotationMethod = this.annotationMethod;
ret.annotationString = this.annotationString;
ret.copyLocationFrom(this);
return ret;
}
-
+
public boolean isAdviceLike() {
return false;
}
public void setAnnotationString(String as) {
this.annotationString = as;
}
-
- public void setAnnotationMethod(String methName){
+
+ public void setAnnotationMethod(String methName) {
this.annotationMethod = methName;
}
-
-
-
+
public boolean equals(Object obj) {
- if (!(obj instanceof DeclareAnnotation)) return false;
+ if (!(obj instanceof DeclareAnnotation))
+ return false;
DeclareAnnotation other = (DeclareAnnotation) obj;
- if (!this.kind.equals(other.kind)) return false;
- if (!this.annotationString.equals(other.annotationString)) return false;
- if (!this.annotationMethod.equals(other.annotationMethod)) return false;
+ if (!this.kind.equals(other.kind))
+ return false;
+ if (!this.annotationString.equals(other.annotationString))
+ return false;
+ if (!this.annotationMethod.equals(other.annotationMethod))
+ return false;
if (this.typePattern != null) {
- if (!typePattern.equals(other.typePattern)) return false;
+ if (!typePattern.equals(other.typePattern))
+ return false;
}
if (this.sigPattern != null) {
- if (!sigPattern.equals(other.sigPattern)) return false;
+ if (!sigPattern.equals(other.sigPattern))
+ return false;
}
return true;
}
-
+
public int hashCode() {
- int result = 19;
- result = 37*result + kind.hashCode();
- result = 37*result + annotationString.hashCode();
- result = 37*result + annotationMethod.hashCode();
- if (typePattern != null) result = 37*result + typePattern.hashCode();
- if (sigPattern != null) result = 37*result + sigPattern.hashCode();
- return result;
- }
-
- /* (non-Javadoc)
- * @see org.aspectj.weaver.patterns.PatternNode#write(java.io.DataOutputStream)
+ int result = 19;
+ result = 37 * result + kind.hashCode();
+ result = 37 * result + annotationString.hashCode();
+ result = 37 * result + annotationMethod.hashCode();
+ if (typePattern != null)
+ result = 37 * result + typePattern.hashCode();
+ if (sigPattern != null)
+ result = 37 * result + sigPattern.hashCode();
+ return result;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.patterns.PatternNode#write(java.io.DataOutputStream)
*/
public void write(DataOutputStream s) throws IOException {
s.writeByte(Declare.ANNOTATION);
s.writeInt(kind.id);
s.writeUTF(annotationString);
s.writeUTF(annotationMethod);
- if (typePattern != null) typePattern.write(s);
- if (sigPattern != null) sigPattern.write(s);
- writeLocation(s);
+ if (typePattern != null)
+ typePattern.write(s);
+ if (sigPattern != null)
+ sigPattern.write(s);
+ writeLocation(s);
}
public static Declare read(VersionedDataInputStream s,
TypePattern tp = null;
SignaturePattern sp = null;
switch (kind) {
- case 1:
- tp = TypePattern.read(s,context);
- ret = new DeclareAnnotation(AT_TYPE,tp);
+ case 1:
+ tp = TypePattern.read(s, context);
+ ret = new DeclareAnnotation(AT_TYPE, tp);
break;
- case 2:
- sp = SignaturePattern.read(s,context);
- ret = new DeclareAnnotation(AT_FIELD,sp);
+ case 2:
+ sp = SignaturePattern.read(s, context);
+ ret = new DeclareAnnotation(AT_FIELD, sp);
break;
- case 3:
- sp = SignaturePattern.read(s,context);
- ret = new DeclareAnnotation(AT_METHOD,sp);
+ case 3:
+ sp = SignaturePattern.read(s, context);
+ ret = new DeclareAnnotation(AT_METHOD, sp);
break;
- case 4:
- sp = SignaturePattern.read(s,context);
- ret = new DeclareAnnotation(AT_CONSTRUCTOR,sp);
+ case 4:
+ sp = SignaturePattern.read(s, context);
+ ret = new DeclareAnnotation(AT_CONSTRUCTOR, sp);
break;
-
+
}
-// if (kind==AT_TYPE.id) {
-// tp = TypePattern.read(s,context);
-// ret = new DeclareAnnotation(AT_TYPE,tp);
-// } else {
-// sp = SignaturePattern.read(s,context);
-// ret = new DeclareAnnotation(kind,sp);
-// }
+ // if (kind==AT_TYPE.id) {
+ // tp = TypePattern.read(s,context);
+ // ret = new DeclareAnnotation(AT_TYPE,tp);
+ // } else {
+ // sp = SignaturePattern.read(s,context);
+ // ret = new DeclareAnnotation(kind,sp);
+ // }
ret.setAnnotationString(annotationString);
ret.setAnnotationMethod(annotationMethod);
- ret.readLocation(context,s);
+ ret.readLocation(context, s);
return ret;
}
+ // public boolean getAnnotationIfMatches(ResolvedType onType) {
+ // return (match(onType));
+ // }
-// public boolean getAnnotationIfMatches(ResolvedType onType) {
-// return (match(onType));
-// }
-
-
- /**
- * For @constructor, @method, @field
- */
- public boolean matches(ResolvedMember rm,World world) {
- return sigPattern.matches(rm,world,false);
+ /**
+ * For @constructor, @method, @field
+ */
+ public boolean matches(ResolvedMember rm, World world) {
+ return sigPattern.matches(rm, world, false);
}
-
- /**
- * For @type
- */
+
+ /**
+ * For @type
+ */
public boolean matches(ResolvedType typeX) {
- if (!typePattern.matchesStatically(typeX)) return false;
- if (typeX.getWorld().getLint().typeNotExposedToWeaver.isEnabled() &&
- !typeX.isExposedToWeaver())
- {
- typeX.getWorld().getLint().typeNotExposedToWeaver.signal(typeX.getName(), getSourceLocation());
+ if (!typePattern.matchesStatically(typeX))
+ return false;
+ if (typeX.getWorld().getLint().typeNotExposedToWeaver.isEnabled()
+ && !typeX.isExposedToWeaver()) {
+ typeX.getWorld().getLint().typeNotExposedToWeaver.signal(typeX
+ .getName(), getSourceLocation());
}
- return true;
+ return true;
}
public void setAspect(ResolvedType typeX) {
public void copyAnnotationTo(ResolvedType onType) {
ensureAnnotationDiscovered();
- if (!onType.hasAnnotation(annotation.getSignature())) {
- onType.addAnnotation(annotation);
+ if (!onType.hasAnnotation(annotation.getType())) {
+ onType.addAnnotation(annotation);
}
}
-
- public AnnotationX getAnnotationX() {
+
+ public AnnotationAJ getAnnotationX() {
ensureAnnotationDiscovered();
return annotation;
}
-
/**
- * The annotation specified in the declare @type is stored against
- * a simple method of the form "ajc$declare_<NN>", this method
- * finds that method and retrieves the annotation
+ * The annotation specified in the declare @type is stored against a simple
+ * method of the form "ajc$declare_<NN>", this method finds that method and
+ * retrieves the annotation
*/
private void ensureAnnotationDiscovered() {
- if (annotation!=null) return;
+ if (annotation != null)
+ return;
for (Iterator iter = containingAspect.getMethods(); iter.hasNext();) {
ResolvedMember member = (ResolvedMember) iter.next();
if (member.getName().equals(annotationMethod)) {
annotation = member.getAnnotations()[0];
- }
+ }
}
}
public TypePattern getTypePattern() {
return typePattern;
}
-
+
public SignaturePattern getSignaturePattern() {
return sigPattern;
}
-
+
public boolean isStarredAnnotationPattern() {
- if (typePattern!=null) return typePattern.isStarAnnotation();
- if (sigPattern!=null) return sigPattern.isStarAnnotation();
- throw new RuntimeException("Impossible! what kind of deca is this: "+this);
+ if (typePattern != null)
+ return typePattern.isStarAnnotation();
+ if (sigPattern != null)
+ return sigPattern.isStarAnnotation();
+ throw new RuntimeException("Impossible! what kind of deca is this: "
+ + this);
}
-
public Kind getKind() {
return kind;
}
public boolean isDeclareAtConstuctor() {
return kind.equals(AT_CONSTRUCTOR);
}
+
public boolean isDeclareAtMethod() {
return kind.equals(AT_METHOD);
}
+
public boolean isDeclareAtType() {
return kind.equals(AT_TYPE);
}
+
public boolean isDeclareAtField() {
return kind.equals(AT_FIELD);
}
- /**
- * @return UnresolvedType for the annotation
- */
+ /**
+ * @return UnresolvedType for the annotation
+ */
public UnresolvedType getAnnotationTypeX() {
- ensureAnnotationDiscovered();
- return this.annotation.getSignature();
+ ensureAnnotationDiscovered();
+ return this.annotation.getType();
}
/**
* @return true if the annotation specified is allowed on a field
*/
public boolean isAnnotationAllowedOnField() {
- ensureAnnotationDiscovered();
+ ensureAnnotationDiscovered();
return annotation.allowedOnField();
}
public String getPatternAsString() {
- if (sigPattern!=null) return sigPattern.toString();
- if (typePattern!=null) return typePattern.toString();
- return "DONT KNOW";
+ if (sigPattern != null)
+ return sigPattern.toString();
+ if (typePattern != null)
+ return typePattern.toString();
+ return "DONT KNOW";
}
/**
- * Return true if this declare annotation could ever match something
- * in the specified type - only really able to make intelligent
- * decision if a type was specified in the sig/type pattern
- * signature.
+ * Return true if this declare annotation could ever match something in the
+ * specified type - only really able to make intelligent decision if a type
+ * was specified in the sig/type pattern signature.
*/
public boolean couldEverMatch(ResolvedType type) {
- // Haven't implemented variant for typePattern (doesn't seem worth it!)
- // BUGWARNING This test might not be sufficient for funny cases relating
+ // Haven't implemented variant for typePattern (doesn't seem worth it!)
+ // BUGWARNING This test might not be sufficient for funny cases relating
// to interfaces and the use of '+' - but it seems really important to
// do something here so we don't iterate over all fields and all methods
- // in all types exposed to the weaver! So look out for bugs here and
+ // in all types exposed to the weaver! So look out for bugs here and
// we can update the test as appropriate.
- if (sigPattern!=null)
- return sigPattern.getDeclaringType().matches(type,TypePattern.STATIC).maybeTrue();
+ if (sigPattern != null)
+ return sigPattern.getDeclaringType().matches(type,
+ TypePattern.STATIC).maybeTrue();
return true;
}
-
+
/**
- * Provide a name suffix so that we can tell the different declare annotations
- * forms apart in the AjProblemReporter
+ * Provide a name suffix so that we can tell the different declare
+ * annotations forms apart in the AjProblemReporter
*/
public String getNameSuffix() {
- return getKind().toString();
+ return getKind().toString();
}
}
import org.aspectj.bridge.MessageUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.AnnotatedElement;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ReferenceType;
protected boolean resolved = false;
protected boolean bindingPattern = false;
private Map annotationValues;
-
- // OPTIMIZE is annotationtype really unresolved???? surely it is resolved by now...
- public ExactAnnotationTypePattern(UnresolvedType annotationType, Map annotationValues) {
+
+ // OPTIMIZE is annotationtype really unresolved???? surely it is resolved by
+ // now...
+ public ExactAnnotationTypePattern(UnresolvedType annotationType,
+ Map annotationValues) {
this.annotationType = annotationType;
this.annotationValues = annotationValues;
this.resolved = (annotationType instanceof ResolvedType);
}
-
+
// Used when deserializing, values will be added
private ExactAnnotationTypePattern(UnresolvedType annotationType) {
this.annotationType = annotationType;
}
public ResolvedType getResolvedAnnotationType() {
- if (!resolved) throw new IllegalStateException("I need to be resolved first!");
+ if (!resolved)
+ throw new IllegalStateException("I need to be resolved first!");
return (ResolvedType) annotationType;
}
-
- public UnresolvedType getAnnotationType() {
- return annotationType;
- }
-
- public Map getAnnotationValues() {
- return annotationValues;
- }
+
+ public UnresolvedType getAnnotationType() {
+ return annotationType;
+ }
+
+ public Map getAnnotationValues() {
+ return annotationValues;
+ }
public FuzzyBoolean fastMatches(AnnotatedElement annotated) {
if (annotated.hasAnnotation(annotationType) && annotationValues == null) {
return FuzzyBoolean.YES;
} else {
- // could be inherited, but we don't know that until we are
+ // could be inherited, but we don't know that until we are
// resolved, and we're not yet...
return FuzzyBoolean.MAYBE;
}
}
-
+
public FuzzyBoolean matches(AnnotatedElement annotated) {
- return matches(annotated,null);
+ return matches(annotated, null);
}
-
- public FuzzyBoolean matches(AnnotatedElement annotated,ResolvedType[] parameterAnnotations) {
+
+ public FuzzyBoolean matches(AnnotatedElement annotated,
+ ResolvedType[] parameterAnnotations) {
if (!isForParameterAnnotationMatch()) {
boolean checkSupers = false;
- if (getResolvedAnnotationType().hasAnnotation(UnresolvedType.AT_INHERITED)) {
+ if (getResolvedAnnotationType().hasAnnotation(
+ UnresolvedType.AT_INHERITED)) {
if (annotated instanceof ResolvedType) {
checkSupers = true;
}
}
-
+
if (annotated.hasAnnotation(annotationType)) {
if (annotationType instanceof ReferenceType) {
- ReferenceType rt = (ReferenceType)annotationType;
- if (rt.getRetentionPolicy()!=null && rt.getRetentionPolicy().equals("SOURCE")) {
- rt.getWorld().getMessageHandler().handleMessage(
- MessageUtil.warn(WeaverMessages.format(WeaverMessages.NO_MATCH_BECAUSE_SOURCE_RETENTION,annotationType,annotated),getSourceLocation()));
+ ReferenceType rt = (ReferenceType) annotationType;
+ if (rt.getRetentionPolicy() != null
+ && rt.getRetentionPolicy().equals("SOURCE")) {
+ rt
+ .getWorld()
+ .getMessageHandler()
+ .handleMessage(
+ MessageUtil
+ .warn(
+ WeaverMessages
+ .format(
+ WeaverMessages.NO_MATCH_BECAUSE_SOURCE_RETENTION,
+ annotationType,
+ annotated),
+ getSourceLocation()));
return FuzzyBoolean.NO;
}
}
-
-
+
// Are we also matching annotation values?
- if (annotationValues!=null) {
- AnnotationX theAnnotation = annotated.getAnnotationOfType(annotationType);
-
+ if (annotationValues != null) {
+ AnnotationAJ theAnnotation = annotated
+ .getAnnotationOfType(annotationType);
+
// Check each one
Set keys = annotationValues.keySet();
for (Iterator keyIter = keys.iterator(); keyIter.hasNext();) {
String k = (String) keyIter.next();
- String v = (String)annotationValues.get(k);
+ String v = (String) annotationValues.get(k);
if (theAnnotation.hasNamedValue(k)) {
- // Simple case, value is 'name=value' and the annotation specified the same thing
- if (!theAnnotation.hasNameValuePair(k,v)) {
+ // Simple case, value is 'name=value' and the
+ // annotation specified the same thing
+ if (!theAnnotation.hasNameValuePair(k, v)) {
return FuzzyBoolean.NO;
- }
+ }
} else {
// Complex case, look at the default value
- ResolvedMember[] ms = ((ResolvedType)annotationType).getDeclaredMethods();
+ ResolvedMember[] ms = ((ResolvedType) annotationType)
+ .getDeclaredMethods();
boolean foundMatch = false;
- for (int i=0; i<ms.length && !foundMatch;i++) {
- if (ms[i].isAbstract() && ms[i].getParameterTypes().length==0 && ms[i].getName().equals(k)) {
+ for (int i = 0; i < ms.length && !foundMatch; i++) {
+ if (ms[i].isAbstract()
+ && ms[i].getParameterTypes().length == 0
+ && ms[i].getName().equals(k)) {
// we might be onto something
- String s= ms[i].getAnnotationDefaultValue();
- if (s!=null && s.equals(v)) foundMatch=true;
+ String s = ms[i]
+ .getAnnotationDefaultValue();
+ if (s != null && s.equals(v))
+ foundMatch = true;
}
}
if (!foundMatch)
- return FuzzyBoolean.NO;
+ return FuzzyBoolean.NO;
}
}
}
return FuzzyBoolean.YES;
} else if (checkSupers) {
- ResolvedType toMatchAgainst = ((ResolvedType) annotated).getSuperclass();
+ ResolvedType toMatchAgainst = ((ResolvedType) annotated)
+ .getSuperclass();
while (toMatchAgainst != null) {
if (toMatchAgainst.hasAnnotation(annotationType)) {
// Are we also matching annotation values?
- if (annotationValues!=null) {
- AnnotationX theAnnotation = toMatchAgainst.getAnnotationOfType(annotationType);
-
+ if (annotationValues != null) {
+ AnnotationAJ theAnnotation = toMatchAgainst
+ .getAnnotationOfType(annotationType);
+
// Check each one
Set keys = annotationValues.keySet();
- for (Iterator keyIter = keys.iterator(); keyIter.hasNext();) {
+ for (Iterator keyIter = keys.iterator(); keyIter
+ .hasNext();) {
String k = (String) keyIter.next();
- String v = (String)annotationValues.get(k);
+ String v = (String) annotationValues.get(k);
if (theAnnotation.hasNamedValue(k)) {
- // Simple case, value is 'name=value' and the annotation specified the same thing
- if (!theAnnotation.hasNameValuePair(k,v)) {
+ // Simple case, value is 'name=value' and
+ // the annotation specified the same thing
+ if (!theAnnotation.hasNameValuePair(k, v)) {
return FuzzyBoolean.NO;
- }
+ }
} else {
// Complex case, look at the default value
- ResolvedMember[] ms = ((ResolvedType)annotationType).getDeclaredMethods();
+ ResolvedMember[] ms = ((ResolvedType) annotationType)
+ .getDeclaredMethods();
boolean foundMatch = false;
- for (int i=0; i<ms.length && !foundMatch;i++) {
- if (ms[i].isAbstract() && ms[i].getParameterTypes().length==0 && ms[i].getName().equals(k)) {
+ for (int i = 0; i < ms.length
+ && !foundMatch; i++) {
+ if (ms[i].isAbstract()
+ && ms[i].getParameterTypes().length == 0
+ && ms[i].getName().equals(k)) {
// we might be onto something
- String s= ms[i].getAnnotationDefaultValue();
- if (s!=null && s.equals(v)) foundMatch=true;
+ String s = ms[i]
+ .getAnnotationDefaultValue();
+ if (s != null && s.equals(v))
+ foundMatch = true;
}
}
if (!foundMatch)
- return FuzzyBoolean.NO;
+ return FuzzyBoolean.NO;
}
}
}
}
toMatchAgainst = toMatchAgainst.getSuperclass();
}
- }
+ }
} else {
// check parameter annotations
- if (parameterAnnotations==null) return FuzzyBoolean.NO;
+ if (parameterAnnotations == null)
+ return FuzzyBoolean.NO;
for (int i = 0; i < parameterAnnotations.length; i++) {
if (annotationType.equals(parameterAnnotations[i])) {
// Are we also matching annotation values?
- if (annotationValues!=null) {
- parameterAnnotations[i].getWorld().getMessageHandler().handleMessage(
- MessageUtil.error("Compiler limitation: annotation value matching for parameter annotations not yet supported"));
+ if (annotationValues != null) {
+ parameterAnnotations[i]
+ .getWorld()
+ .getMessageHandler()
+ .handleMessage(
+ MessageUtil
+ .error("Compiler limitation: annotation value matching for parameter annotations not yet supported"));
return FuzzyBoolean.NO;
}
return FuzzyBoolean.YES;
}
}
}
-
-
+
return FuzzyBoolean.NO;
}
-
+
// this version should be called for @this, @target, @args
public FuzzyBoolean matchesRuntimeType(AnnotatedElement annotated) {
- if (getResolvedAnnotationType().hasAnnotation(UnresolvedType.AT_INHERITED)) {
+ if (getResolvedAnnotationType().hasAnnotation(
+ UnresolvedType.AT_INHERITED)) {
// a static match is good enough
if (matches(annotated).alwaysTrue()) {
return FuzzyBoolean.YES;
- }
+ }
}
// a subtype could match at runtime
return FuzzyBoolean.MAYBE;
}
-
public void resolve(World world) {
if (!resolved) {
annotationType = annotationType.resolve(world);
resolved = true;
}
- /* (non-Javadoc)
- * @see org.aspectj.weaver.patterns.AnnotationTypePattern#resolveBindings(org.aspectj.weaver.patterns.IScope, org.aspectj.weaver.patterns.Bindings, boolean)
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.patterns.AnnotationTypePattern#resolveBindings(org
+ * .aspectj.weaver.patterns.IScope, org.aspectj.weaver.patterns.Bindings,
+ * boolean)
*/
public AnnotationTypePattern resolveBindings(IScope scope,
Bindings bindings, boolean allowBinding) {
- if (resolved) return this;
+ if (resolved)
+ return this;
resolved = true;
String simpleName = maybeGetSimpleName();
if (simpleName != null) {
FormalBinding formalBinding = scope.lookupFormal(simpleName);
if (formalBinding != null) {
if (bindings == null) {
- scope.message(IMessage.ERROR, this, "negation doesn't allow binding");
+ scope.message(IMessage.ERROR, this,
+ "negation doesn't allow binding");
return this;
}
if (!allowBinding) {
- scope.message(IMessage.ERROR, this,
- "name binding only allowed in @pcds, args, this, and target");
+ scope
+ .message(IMessage.ERROR, this,
+ "name binding only allowed in @pcds, args, this, and target");
return this;
}
formalName = simpleName;
bindingPattern = true;
- verifyIsAnnotationType(formalBinding.getType().resolve(scope.getWorld()),scope);
- BindingAnnotationTypePattern binding = new BindingAnnotationTypePattern(formalBinding);
+ verifyIsAnnotationType(formalBinding.getType().resolve(
+ scope.getWorld()), scope);
+ BindingAnnotationTypePattern binding = new BindingAnnotationTypePattern(
+ formalBinding);
binding.copyLocationFrom(this);
bindings.register(binding, scope);
binding.resolveBinding(scope.getWorld());
- if (isForParameterAnnotationMatch()) binding.setForParameterAnnotationMatch();
-
+ if (isForParameterAnnotationMatch())
+ binding.setForParameterAnnotationMatch();
+
return binding;
- }
+ }
}
// Non binding case
String cleanname = annotationType.getName();
- annotationType = scope.getWorld().resolve(annotationType,true);
-
+ annotationType = scope.getWorld().resolve(annotationType, true);
+
// We may not have found it if it is in a package, lets look it up...
if (ResolvedType.isMissing(annotationType)) {
UnresolvedType type = null;
- while (ResolvedType.isMissing(type = scope.lookupType(cleanname,this))) {
+ while (ResolvedType.isMissing(type = scope.lookupType(cleanname,
+ this))) {
int lastDot = cleanname.lastIndexOf('.');
- if (lastDot == -1) break;
- cleanname = cleanname.substring(0,lastDot)+"$"+cleanname.substring(lastDot+1);
+ if (lastDot == -1)
+ break;
+ cleanname = cleanname.substring(0, lastDot) + "$"
+ + cleanname.substring(lastDot + 1);
}
- annotationType = scope.getWorld().resolve(type,true);
+ annotationType = scope.getWorld().resolve(type, true);
}
-
- verifyIsAnnotationType((ResolvedType)annotationType,scope);
+
+ verifyIsAnnotationType((ResolvedType) annotationType, scope);
return this;
}
-
- public AnnotationTypePattern parameterizeWith(Map typeVariableMap,World w) {
+
+ public AnnotationTypePattern parameterizeWith(Map typeVariableMap, World w) {
UnresolvedType newAnnotationType = annotationType;
if (annotationType.isTypeVariableReference()) {
TypeVariableReference t = (TypeVariableReference) annotationType;
} else if (annotationType.isParameterizedType()) {
newAnnotationType = annotationType.parameterize(typeVariableMap);
}
- ExactAnnotationTypePattern ret = new ExactAnnotationTypePattern(newAnnotationType,annotationValues);
+ ExactAnnotationTypePattern ret = new ExactAnnotationTypePattern(
+ newAnnotationType, annotationValues);
ret.formalName = formalName;
ret.bindingPattern = bindingPattern;
ret.copyLocationFrom(this);
- if (isForParameterAnnotationMatch()) ret.setForParameterAnnotationMatch();
+ if (isForParameterAnnotationMatch())
+ ret.setForParameterAnnotationMatch();
return ret;
}
-
+
protected String maybeGetSimpleName() {
- if (formalName != null) return formalName;
+ if (formalName != null)
+ return formalName;
String ret = annotationType.getName();
return (ret.indexOf('.') == -1) ? ret : null;
}
-
+
protected void verifyIsAnnotationType(ResolvedType type, IScope scope) {
if (!type.isAnnotation()) {
- IMessage m = MessageUtil.error(
- WeaverMessages.format(WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE,type.getName()),
- getSourceLocation());
+ IMessage m = MessageUtil.error(WeaverMessages.format(
+ WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE, type
+ .getName()), getSourceLocation());
scope.getWorld().getMessageHandler().handleMessage(m);
resolved = false;
}
}
private static byte VERSION = 1; // rev if serialisation form changes
- /* (non-Javadoc)
- * @see org.aspectj.weaver.patterns.PatternNode#write(java.io.DataOutputStream)
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.patterns.PatternNode#write(java.io.DataOutputStream)
*/
public void write(DataOutputStream s) throws IOException {
s.writeByte(AnnotationTypePattern.EXACT);
}
writeLocation(s);
s.writeBoolean(isForParameterAnnotationMatch());
- if (annotationValues==null) {
+ if (annotationValues == null) {
s.writeInt(0);
} else {
s.writeInt(annotationValues.size());
for (Iterator keys = key.iterator(); keys.hasNext();) {
String k = (String) keys.next();
s.writeUTF(k);
- s.writeUTF((String)annotationValues.get(k));
+ s.writeUTF((String) annotationValues.get(k));
}
}
}
- public static AnnotationTypePattern read(VersionedDataInputStream s,ISourceContext context) throws IOException {
+ public static AnnotationTypePattern read(VersionedDataInputStream s,
+ ISourceContext context) throws IOException {
ExactAnnotationTypePattern ret;
byte version = s.readByte();
if (version > VERSION) {
- throw new BCException("ExactAnnotationTypePattern was written by a newer version of AspectJ");
+ throw new BCException(
+ "ExactAnnotationTypePattern was written by a newer version of AspectJ");
}
boolean isBindingPattern = s.readBoolean();
if (isBindingPattern) {
ret = new ExactAnnotationTypePattern(s.readUTF());
} else {
- ret = new ExactAnnotationTypePattern(UnresolvedType.read(s));
+ ret = new ExactAnnotationTypePattern(UnresolvedType.read(s));
}
- ret.readLocation(context,s);
- if (s.getMajorVersion()>=WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160) {
- if (s.readBoolean()) ret.setForParameterAnnotationMatch();
+ ret.readLocation(context, s);
+ if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160) {
+ if (s.readBoolean())
+ ret.setForParameterAnnotationMatch();
}
- if (s.getMajorVersion()>=WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160M2) {
+ if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160M2) {
int annotationValueCount = s.readInt();
- if (annotationValueCount>0) {
+ if (annotationValueCount > 0) {
Map aValues = new HashMap();
- for (int i=0;i<annotationValueCount;i++) {
+ for (int i = 0; i < annotationValueCount; i++) {
String key = s.readUTF();
String val = s.readUTF();
- aValues.put(key,val);
+ aValues.put(key, val);
}
ret.annotationValues = aValues;
}
}
return ret;
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
- if (!(obj instanceof ExactAnnotationTypePattern)) return false;
+ if (!(obj instanceof ExactAnnotationTypePattern))
+ return false;
ExactAnnotationTypePattern other = (ExactAnnotationTypePattern) obj;
- return (other.annotationType.equals(annotationType)) && isForParameterAnnotationMatch()==other.isForParameterAnnotationMatch() &&
- (annotationValues==null?other.annotationValues==null:annotationValues.equals(other.annotationValues));
+ return (other.annotationType.equals(annotationType))
+ && isForParameterAnnotationMatch() == other
+ .isForParameterAnnotationMatch()
+ && (annotationValues == null ? other.annotationValues == null
+ : annotationValues.equals(other.annotationValues));
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
- return (((annotationType.hashCode())*37+(isForParameterAnnotationMatch()?0:1))*37)+(annotationValues==null?0:annotationValues.hashCode());
+ return (((annotationType.hashCode()) * 37 + (isForParameterAnnotationMatch() ? 0
+ : 1)) * 37)
+ + (annotationValues == null ? 0 : annotationValues.hashCode());
}
-
+
public String toString() {
- if (!resolved && formalName != null) return formalName;
+ if (!resolved && formalName != null)
+ return formalName;
String ret = "@" + annotationType.toString();
- if (formalName != null) ret = ret + " " + formalName;
+ if (formalName != null)
+ ret = ret + " " + formalName;
return ret;
}
- public Object accept(PatternNodeVisitor visitor, Object data) {
- return visitor.visit(this, data);
- }
+ public Object accept(PatternNodeVisitor visitor, Object data) {
+ return visitor.visit(this, data);
+ }
}
import java.lang.reflect.Member;
import java.util.Set;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.World;
/**
- * @author colyer
- * Used in 1.4 code to access annotations safely
+ * @author colyer Used in 1.4 code to access annotations safely
*/
public interface AnnotationFinder {
void setClassLoader(ClassLoader annotationLoader);
-
+
void setWorld(World aWorld);
-
+
Object getAnnotation(ResolvedType annotationType, Object onObject);
-
+
Object getAnnotationFromMember(ResolvedType annotationType, Member aMember);
- public AnnotationX getAnnotationOfType(UnresolvedType ofType,Member onMember);
-
+
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType,
+ Member onMember);
+
public String getAnnotationDefaultValue(Member onMember);
-
+
Object getAnnotationFromClass(ResolvedType annotationType, Class aClass);
-
- Set/*ResolvedType*/ getAnnotations(Member onMember);
-
+
+ Set/* ResolvedType */getAnnotations(Member onMember);
+
ResolvedType[][] getParameterAnnotationTypes(Member onMember);
}
import java.util.Collection;
import java.util.Collections;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationTargetKind;
-import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ReferenceTypeDelegate;
import org.aspectj.weaver.patterns.PerClause;
/**
- * @author colyer
- * A delegate for a resolved type that uses runtime type information (java.lang.reflect)
- * to answer questions. This class uses only Java 1.4 features to answer questions.
- * In a Java 1.5 environment use the Java5ReflectionBasedReferenceTypeDelegate subtype.
+ * @author colyer A delegate for a resolved type that uses runtime type
+ * information (java.lang.reflect) to answer questions. This class uses
+ * only Java 1.4 features to answer questions. In a Java 1.5 environment
+ * use the Java5ReflectionBasedReferenceTypeDelegate subtype.
*/
-public class ReflectionBasedReferenceTypeDelegate implements ReferenceTypeDelegate {
+public class ReflectionBasedReferenceTypeDelegate implements
+ ReferenceTypeDelegate {
+
+ private static final ClassLoader BootClassLoader = new URLClassLoader(
+ new URL[0]);// ReflectionBasedReferenceTypeDelegate.class.
+ // getClassLoader();
- private static final ClassLoader BootClassLoader = new URLClassLoader(new URL[0]);// ReflectionBasedReferenceTypeDelegate.class.getClassLoader();
-
protected Class myClass = null;
protected WeakClassLoaderReference classLoaderReference = null;
private World world;
private ResolvedMember[] fields = null;
private ResolvedMember[] methods = null;
private ResolvedType[] interfaces = null;
-
- public ReflectionBasedReferenceTypeDelegate(Class forClass, ClassLoader aClassLoader, World inWorld, ReferenceType resolvedType) {
- initialize(resolvedType,forClass, aClassLoader, inWorld);
+
+ public ReflectionBasedReferenceTypeDelegate(Class forClass,
+ ClassLoader aClassLoader, World inWorld, ReferenceType resolvedType) {
+ initialize(resolvedType, forClass, aClassLoader, inWorld);
}
-
+
/** for reflective construction only */
- public ReflectionBasedReferenceTypeDelegate() {}
-
- public void initialize(ReferenceType aType, Class aClass, ClassLoader aClassLoader, World aWorld) {
+ public ReflectionBasedReferenceTypeDelegate() {
+ }
+
+ public void initialize(ReferenceType aType, Class aClass,
+ ClassLoader aClassLoader, World aWorld) {
this.myClass = aClass;
this.resolvedType = aType;
this.world = aWorld;
- this.classLoaderReference = new WeakClassLoaderReference((aClassLoader != null) ? aClassLoader : BootClassLoader);
+ this.classLoaderReference = new WeakClassLoaderReference(
+ (aClassLoader != null) ? aClassLoader : BootClassLoader);
}
-
- protected Class getBaseClass() {
+
+ protected Class getBaseClass() {
return this.myClass;
}
-
+
protected World getWorld() {
return this.world;
}
-
+
public ReferenceType buildGenericType() {
- throw new UnsupportedOperationException("Shouldn't be asking for generic type at 1.4 source level or lower");
+ throw new UnsupportedOperationException(
+ "Shouldn't be asking for generic type at 1.4 source level or lower");
}
-
- /* (non-Javadoc)
- * @see org.aspectj.weaver.ReferenceTypeDelegate#addAnnotation(org.aspectj.weaver.AnnotationX)
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.ReferenceTypeDelegate#addAnnotation(org.aspectj.weaver
+ * .AnnotationX)
*/
- public void addAnnotation(AnnotationX annotationX) {
- throw new UnsupportedOperationException("Cannot add an annotation to a reflection based delegate");
+ public void addAnnotation(AnnotationAJ annotationX) {
+ throw new UnsupportedOperationException(
+ "Cannot add an annotation to a reflection based delegate");
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isAspect()
*/
public boolean isAspect() {
- // we could do better than this in Java 5 by looking at the annotations on the type...
+ // we could do better than this in Java 5 by looking at the annotations
+ // on the type...
return false;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isAnnotationStyleAspect()
*/
public boolean isAnnotationStyleAspect() {
- // we could do better than this in Java 5 by looking at the annotations on the type...
+ // we could do better than this in Java 5 by looking at the annotations
+ // on the type...
return false;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isInterface()
*/
public boolean isInterface() {
return this.myClass.isInterface();
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isEnum()
*/
public boolean isEnum() {
return false;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isAnnotation()
*/
public boolean isAnnotation() {
return false;
}
- /* (non-Javadoc)
- * @see org.aspectj.weaver.ReferenceTypeDelegate#isAnnotationWithRuntimeRetention()
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.ReferenceTypeDelegate#isAnnotationWithRuntimeRetention
+ * ()
*/
public boolean isAnnotationWithRuntimeRetention() {
// cant be an annotation in Java 1.4 or prior
return false;
}
-
+
public String getRetentionPolicy() {
// cant be an annotation in Java 1.4 or prior
return null;
public boolean canAnnotationTargetType() {
return false;
}
-
+
public AnnotationTargetKind[] getAnnotationTargetKinds() {
return null;
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isClass()
*/
public boolean isClass() {
- return !this.myClass.isInterface() && !this.myClass.isPrimitive() && !this.myClass.isArray();
+ return !this.myClass.isInterface() && !this.myClass.isPrimitive()
+ && !this.myClass.isArray();
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isGeneric()
*/
public boolean isGeneric() {
// cant be generic in 1.4
return false;
}
-
+
public boolean isAnonymous() {
return false;
}
-
+
public boolean isNested() {
- // FIXME this is *wrong* but isMemberClass() doesnt exist in pre-1.5... (same deal as isAnonymous above...)
+ // FIXME this is *wrong* but isMemberClass() doesnt exist in pre-1.5...
+ // (same deal as isAnonymous above...)
return true;
-// boolean member = this.myClass.isMemberClass();
-// return member;
+ // boolean member = this.myClass.isMemberClass();
+ // return member;
}
-
+
public ResolvedType getOuterClass() {
// FIXME getEnclosingClass() is Java5 ... dammit
-// return ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(myClass.getEnclosingClass(),world);
+ // return
+ // ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(
+ // myClass.getEnclosingClass(),world);
return null;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#isExposedToWeaver()
*/
public boolean isExposedToWeaver() {
return false;
}
- /* (non-Javadoc)
- * @see org.aspectj.weaver.ReferenceTypeDelegate#hasAnnotation(org.aspectj.weaver.UnresolvedType)
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.ReferenceTypeDelegate#hasAnnotation(org.aspectj.weaver
+ * .UnresolvedType)
*/
public boolean hasAnnotation(UnresolvedType ofType) {
// in Java 1.4 we cant have an annotation
return false;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getAnnotations()
*/
- public AnnotationX[] getAnnotations() {
+ public AnnotationAJ[] getAnnotations() {
// no annotations in Java 1.4
- return new AnnotationX[0];
+ return AnnotationAJ.EMPTY_ARRAY;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getAnnotationTypes()
*/
public ResolvedType[] getAnnotationTypes() {
return new ResolvedType[0];
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredFields()
*/
public ResolvedMember[] getDeclaredFields() {
Field[] reflectFields = this.myClass.getDeclaredFields();
ResolvedMember[] rFields = new ResolvedMember[reflectFields.length];
for (int i = 0; i < reflectFields.length; i++) {
- rFields[i] =
- ReflectionBasedReferenceTypeDelegateFactory.createResolvedMember(reflectFields[i], world);
+ rFields[i] = ReflectionBasedReferenceTypeDelegateFactory
+ .createResolvedMember(reflectFields[i], world);
}
this.fields = rFields;
}
return fields;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredInterfaces()
*/
public ResolvedType[] getDeclaredInterfaces() {
ResolvedType[] rInterfaces = new ResolvedType[reflectInterfaces.length];
for (int i = 0; i < reflectInterfaces.length; i++) {
rInterfaces[i] = ReflectionBasedReferenceTypeDelegateFactory
- .resolveTypeInWorld(reflectInterfaces[i],world);
+ .resolveTypeInWorld(reflectInterfaces[i], world);
}
this.interfaces = rInterfaces;
}
return interfaces;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredMethods()
*/
public ResolvedMember[] getDeclaredMethods() {
if (methods == null) {
Method[] reflectMethods = this.myClass.getDeclaredMethods();
Constructor[] reflectCons = this.myClass.getDeclaredConstructors();
- ResolvedMember[] rMethods = new ResolvedMember[reflectMethods.length + reflectCons.length];
+ ResolvedMember[] rMethods = new ResolvedMember[reflectMethods.length
+ + reflectCons.length];
for (int i = 0; i < reflectMethods.length; i++) {
- rMethods[i] =
- ReflectionBasedReferenceTypeDelegateFactory.createResolvedMember(reflectMethods[i], world);
+ rMethods[i] = ReflectionBasedReferenceTypeDelegateFactory
+ .createResolvedMember(reflectMethods[i], world);
}
for (int i = 0; i < reflectCons.length; i++) {
- rMethods[i + reflectMethods.length] =
- ReflectionBasedReferenceTypeDelegateFactory.createResolvedMember(reflectCons[i], world);
+ rMethods[i + reflectMethods.length] = ReflectionBasedReferenceTypeDelegateFactory
+ .createResolvedMember(reflectCons[i], world);
}
this.methods = rMethods;
}
return methods;
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredPointcuts()
*/
public ResolvedMember[] getDeclaredPointcuts() {
return new ResolvedMember[0];
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getTypeVariables()
*/
public TypeVariable[] getTypeVariables() {
return new TypeVariable[0];
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getPerClause()
*/
public PerClause getPerClause() {
return null;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclares()
*/
public Collection getDeclares() {
return Collections.EMPTY_SET;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getTypeMungers()
*/
public Collection getTypeMungers() {
return Collections.EMPTY_SET;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getPrivilegedAccesses()
*/
public Collection getPrivilegedAccesses() {
return Collections.EMPTY_SET;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getModifiers()
*/
public int getModifiers() {
return this.myClass.getModifiers();
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getSuperclass()
*/
public ResolvedType getSuperclass() {
if (this.myClass.getSuperclass() == null) {
- if (myClass==Object.class) {
+ if (myClass == Object.class) {
return null;
}
return world.resolve(UnresolvedType.OBJECT);
}
- return ReflectionBasedReferenceTypeDelegateFactory
- .resolveTypeInWorld(this.myClass.getSuperclass(),world);
+ return ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(
+ this.myClass.getSuperclass(), world);
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getWeaverState()
*/
public WeaverStateInfo getWeaverState() {
return null;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ReferenceTypeDelegate#getResolvedTypeX()
*/
public ReferenceType getResolvedTypeX() {
return this.resolvedType;
}
- /* (non-Javadoc)
- * @see org.aspectj.weaver.ReferenceTypeDelegate#doesNotExposeShadowMungers()
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.ReferenceTypeDelegate#doesNotExposeShadowMungers()
*/
public boolean doesNotExposeShadowMungers() {
return false;
}
- /* (non-Javadoc)
- * @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredGenericSignature()
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredGenericSignature()
*/
public String getDeclaredGenericSignature() {
// no generic sig in 1.4
}
public void ensureDelegateConsistent() {
- // Nothing to do - a reflection based delegate can't become inconsistent...
+ // Nothing to do - a reflection based delegate can't become
+ // inconsistent...
}
-
- public ReflectionBasedResolvedMemberImpl createResolvedMemberFor(Member aMember) {
+
+ public ReflectionBasedResolvedMemberImpl createResolvedMemberFor(
+ Member aMember) {
return null;
}
-
+
public String getSourcefilename() {
- // crappy guess..
- return resolvedType.getName() + ".class";
+ // crappy guess..
+ return resolvedType.getName() + ".class";
}
public ISourceContext getSourceContext() {
import java.lang.reflect.Member;
import java.util.Iterator;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.MemberKind;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedMemberImpl;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
-
/**
- * Subtype of ResolvedMemberImpl used in reflection world.
- * Knows how to get annotations from a java.lang.reflect.Member
- *
+ * Subtype of ResolvedMemberImpl used in reflection world. Knows how to get
+ * annotations from a java.lang.reflect.Member
+ *
*/
public class ReflectionBasedResolvedMemberImpl extends ResolvedMemberImpl {
private AnnotationFinder annotationFinder = null;
- private GenericSignatureInformationProvider gsigInfoProvider =
- new Java14GenericSignatureInformationProvider();
-
+ private GenericSignatureInformationProvider gsigInfoProvider = new Java14GenericSignatureInformationProvider();
+
private Member reflectMember;
-
+
/**
* @param kind
* @param declaringType
public ReflectionBasedResolvedMemberImpl(MemberKind kind,
UnresolvedType declaringType, int modifiers,
UnresolvedType returnType, String name,
- UnresolvedType[] parameterTypes,
- Member reflectMember) {
+ UnresolvedType[] parameterTypes, Member reflectMember) {
super(kind, declaringType, modifiers, returnType, name, parameterTypes);
this.reflectMember = reflectMember;
}
public ReflectionBasedResolvedMemberImpl(MemberKind kind,
UnresolvedType declaringType, int modifiers,
UnresolvedType returnType, String name,
- UnresolvedType[] parameterTypes, UnresolvedType[] checkedExceptions,
- Member reflectMember) {
+ UnresolvedType[] parameterTypes,
+ UnresolvedType[] checkedExceptions, Member reflectMember) {
super(kind, declaringType, modifiers, returnType, name, parameterTypes,
checkedExceptions);
this.reflectMember = reflectMember;
UnresolvedType returnType, String name,
UnresolvedType[] parameterTypes,
UnresolvedType[] checkedExceptions,
- ResolvedMember backingGenericMember,
- Member reflectMember) {
+ ResolvedMember backingGenericMember, Member reflectMember) {
super(kind, declaringType, modifiers, returnType, name, parameterTypes,
checkedExceptions, backingGenericMember);
this.reflectMember = reflectMember;
public Member getMember() {
return this.reflectMember;
}
-
+
// generic signature support
-
- public void setGenericSignatureInformationProvider(GenericSignatureInformationProvider gsigProvider) {
+
+ public void setGenericSignatureInformationProvider(
+ GenericSignatureInformationProvider gsigProvider) {
this.gsigInfoProvider = gsigProvider;
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ResolvedMemberImpl#getGenericParameterTypes()
*/
public UnresolvedType[] getGenericParameterTypes() {
return this.gsigInfoProvider.getGenericParameterTypes(this);
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ResolvedMemberImpl#getGenericReturnType()
*/
public UnresolvedType getGenericReturnType() {
return this.gsigInfoProvider.getGenericReturnType(this);
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ResolvedMemberImpl#isSynthetic()
*/
public boolean isSynthetic() {
return this.gsigInfoProvider.isSynthetic(this);
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ResolvedMemberImpl#isVarargsMethod()
*/
public boolean isVarargsMethod() {
return this.gsigInfoProvider.isVarArgs(this);
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.ResolvedMemberImpl#isBridgeMethod()
*/
public boolean isBridgeMethod() {
return this.gsigInfoProvider.isBridge(this);
}
-
+
// annotation support
-
+
public void setAnnotationFinder(AnnotationFinder finder) {
this.annotationFinder = finder;
}
-
+
public boolean hasAnnotation(UnresolvedType ofType) {
unpackAnnotations();
return super.hasAnnotation(ofType);
}
-
+
public boolean hasAnnotations() {
unpackAnnotations();
return super.hasAnnotations();
}
-
+
public ResolvedType[] getAnnotationTypes() {
unpackAnnotations();
return super.getAnnotationTypes();
}
-
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
unpackAnnotations();
- if (annotationFinder==null) return null;
+ if (annotationFinder == null)
+ return null;
for (Iterator iterator = annotationTypes.iterator(); iterator.hasNext();) {
ResolvedType type = (ResolvedType) iterator.next();
if (type.getSignature().equals(ofType.getSignature())) {
- return annotationFinder.getAnnotationOfType(ofType, reflectMember);
+ return annotationFinder.getAnnotationOfType(ofType,
+ reflectMember);
}
}
return null;
}
public String getAnnotationDefaultValue() {
- if (annotationFinder==null) return null;
+ if (annotationFinder == null)
+ return null;
return annotationFinder.getAnnotationDefaultValue(reflectMember);
}
public ResolvedType[][] getParameterAnnotationTypes() {
- if (parameterAnnotationTypes==null && annotationFinder!=null) {
- parameterAnnotationTypes = annotationFinder.getParameterAnnotationTypes(reflectMember);
- }
- return parameterAnnotationTypes;
- }
-
+ if (parameterAnnotationTypes == null && annotationFinder != null) {
+ parameterAnnotationTypes = annotationFinder
+ .getParameterAnnotationTypes(reflectMember);
+ }
+ return parameterAnnotationTypes;
+ }
+
private void unpackAnnotations() {
if (annotationTypes == null && annotationFinder != null) {
annotationTypes = annotationFinder.getAnnotations(reflectMember);
import org.aspectj.bridge.AbortException;
import org.aspectj.util.LangUtil;
import org.aspectj.weaver.AnnotatedElement;
-import org.aspectj.weaver.AnnotationX;
+import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.BcweaverTests;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.bcel.BcelWorld;
public class AnnotationPatternTestCase extends TestCase {
-
-
public void testParseSimpleAnnotationPattern() {
PatternParser p = new PatternParser("@Foo");
AnnotationTypePattern foo = p.maybeParseAnnotationPattern();
- foo = foo.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- assertTrue("ExactAnnotationTypePattern",foo instanceof ExactAnnotationTypePattern);
- assertEquals("Foo", UnresolvedType.forSignature("LFoo;"), ((ExactAnnotationTypePattern) foo).annotationType);
+ foo = foo.resolveBindings(makeSimpleScope(), new Bindings(3), true);
+ assertTrue("ExactAnnotationTypePattern",
+ foo instanceof ExactAnnotationTypePattern);
+ assertEquals("Foo", UnresolvedType.forSignature("LFoo;"),
+ ((ExactAnnotationTypePattern) foo).annotationType);
}
-
+
public void testParseAndAnnotationPattern() {
PatternParser p = new PatternParser("@Foo @Goo");
AnnotationTypePattern fooAndGoo = p.maybeParseAnnotationPattern();
- assertTrue("AndAnnotationTypePattern",fooAndGoo instanceof AndAnnotationTypePattern);
- assertEquals("@(Foo) @(Goo)",fooAndGoo.toString());
- fooAndGoo = fooAndGoo.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- assertEquals("@Foo @Goo",fooAndGoo.toString());
- AnnotationTypePattern left = ((AndAnnotationTypePattern)fooAndGoo).getLeft();
- AnnotationTypePattern right = ((AndAnnotationTypePattern)fooAndGoo).getRight();
- assertEquals("Foo", UnresolvedType.forSignature("LFoo;"), ((ExactAnnotationTypePattern) left).annotationType);
- assertEquals("Goo", UnresolvedType.forSignature("LGoo;"), ((ExactAnnotationTypePattern) right).annotationType);
+ assertTrue("AndAnnotationTypePattern",
+ fooAndGoo instanceof AndAnnotationTypePattern);
+ assertEquals("@(Foo) @(Goo)", fooAndGoo.toString());
+ fooAndGoo = fooAndGoo.resolveBindings(makeSimpleScope(),
+ new Bindings(3), true);
+ assertEquals("@Foo @Goo", fooAndGoo.toString());
+ AnnotationTypePattern left = ((AndAnnotationTypePattern) fooAndGoo)
+ .getLeft();
+ AnnotationTypePattern right = ((AndAnnotationTypePattern) fooAndGoo)
+ .getRight();
+ assertEquals("Foo", UnresolvedType.forSignature("LFoo;"),
+ ((ExactAnnotationTypePattern) left).annotationType);
+ assertEquals("Goo", UnresolvedType.forSignature("LGoo;"),
+ ((ExactAnnotationTypePattern) right).annotationType);
}
-//
-// public void testParseOrAnnotationPattern() {
-// PatternParser p = new PatternParser("@Foo || @Goo");
-// AnnotationTypePattern fooOrGoo = p.parseAnnotationTypePattern();
-// assertTrue("OrAnnotationTypePattern",fooOrGoo instanceof OrAnnotationTypePattern);
-// assertEquals("(@Foo || @Goo)",fooOrGoo.toString());
-// AnnotationTypePattern left = ((OrAnnotationTypePattern)fooOrGoo).getLeft();
-// AnnotationTypePattern right = ((OrAnnotationTypePattern)fooOrGoo).getRight();
-// assertEquals("Foo",UnresolvedType.forName("Foo"),((ExactAnnotationTypePattern)left).annotationType);
-// assertEquals("Goo",UnresolvedType.forName("Goo"),((ExactAnnotationTypePattern)right).annotationType);
-// }
-//
+
+ //
+ // public void testParseOrAnnotationPattern() {
+ // PatternParser p = new PatternParser("@Foo || @Goo");
+ // AnnotationTypePattern fooOrGoo = p.parseAnnotationTypePattern();
+ // assertTrue("OrAnnotationTypePattern",fooOrGoo instanceof
+ // OrAnnotationTypePattern);
+ // assertEquals("(@Foo || @Goo)",fooOrGoo.toString());
+ // AnnotationTypePattern left =
+ // ((OrAnnotationTypePattern)fooOrGoo).getLeft();
+ // AnnotationTypePattern right =
+ // ((OrAnnotationTypePattern)fooOrGoo).getRight();
+ // assertEquals("Foo",UnresolvedType.forName("Foo"),((
+ // ExactAnnotationTypePattern)left).annotationType);
+ // assertEquals("Goo",UnresolvedType.forName("Goo"),((
+ // ExactAnnotationTypePattern)right).annotationType);
+ // }
+ //
public void testParseNotAnnotationPattern() {
PatternParser p = new PatternParser("!@Foo");
AnnotationTypePattern notFoo = p.maybeParseAnnotationPattern();
- assertTrue("NotAnnotationTypePattern",notFoo instanceof NotAnnotationTypePattern);
- notFoo = notFoo.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- assertEquals("!@Foo",notFoo.toString());
- AnnotationTypePattern body = ((NotAnnotationTypePattern)notFoo).getNegatedPattern();
- assertEquals("Foo",UnresolvedType.forName("Foo"),((ExactAnnotationTypePattern)body).annotationType);
+ assertTrue("NotAnnotationTypePattern",
+ notFoo instanceof NotAnnotationTypePattern);
+ notFoo = notFoo.resolveBindings(makeSimpleScope(), new Bindings(3),
+ true);
+ assertEquals("!@Foo", notFoo.toString());
+ AnnotationTypePattern body = ((NotAnnotationTypePattern) notFoo)
+ .getNegatedPattern();
+ assertEquals("Foo", UnresolvedType.forName("Foo"),
+ ((ExactAnnotationTypePattern) body).annotationType);
}
public void testParseBracketedAnnotationPattern() {
PatternParser p = new PatternParser("(@Foo)");
AnnotationTypePattern foo = p.maybeParseAnnotationPattern();
// cannot start with ( so, we get ANY
- assertEquals("ANY",AnnotationTypePattern.ANY,foo);
+ assertEquals("ANY", AnnotationTypePattern.ANY, foo);
}
-
+
public void testParseFQAnnPattern() {
PatternParser p = new PatternParser("@org.aspectj.Foo");
AnnotationTypePattern foo = p.maybeParseAnnotationPattern();
- assertEquals("@(org.aspectj.Foo)",foo.toString());
+ assertEquals("@(org.aspectj.Foo)", foo.toString());
}
-
+
public void testParseComboPattern() {
-// PatternParser p = new PatternParser("!((@Foo || @Goo) && !@Boo)");
+ // PatternParser p = new PatternParser("!((@Foo || @Goo) && !@Boo)");
PatternParser p = new PatternParser("@(Foo || Goo)!@Boo");
AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
- ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
+ ap = ap.resolveBindings(makeSimpleScope(), new Bindings(3), true);
AndAnnotationTypePattern atp = (AndAnnotationTypePattern) ap;
- NotAnnotationTypePattern notBoo = (NotAnnotationTypePattern) atp.getRight();
-// ExactAnnotationTypePattern boo = (ExactAnnotationTypePattern)
- notBoo.getNegatedPattern();
-// AnnotationTypePattern fooOrGoo = (AnnotationTypePattern)
- atp.getLeft();
- assertEquals("@((Foo || Goo)) !@Boo",ap.toString());
+ NotAnnotationTypePattern notBoo = (NotAnnotationTypePattern) atp
+ .getRight();
+ // ExactAnnotationTypePattern boo = (ExactAnnotationTypePattern)
+ notBoo.getNegatedPattern();
+ // AnnotationTypePattern fooOrGoo = (AnnotationTypePattern)
+ atp.getLeft();
+ assertEquals("@((Foo || Goo)) !@Boo", ap.toString());
}
-
-// public void testParseAndOrPattern() {
-// PatternParser p = new PatternParser("@Foo && @Boo || @Goo");
-// AnnotationTypePattern andOr = p.parseAnnotationTypePattern();
-// assertTrue("Should be or pattern",andOr instanceof OrAnnotationTypePattern);
-// }
-//
+
+ // public void testParseAndOrPattern() {
+ // PatternParser p = new PatternParser("@Foo && @Boo || @Goo");
+ // AnnotationTypePattern andOr = p.parseAnnotationTypePattern();
+ // assertTrue("Should be or pattern",andOr instanceof
+ // OrAnnotationTypePattern);
+ // }
+ //
public void testParseBadPattern() {
PatternParser p = new PatternParser("@@Foo");
try {
p.maybeParseAnnotationPattern();
fail("ParserException expected");
- } catch(ParserException pEx) {
- assertEquals("name pattern",pEx.getMessage());
+ } catch (ParserException pEx) {
+ assertEquals("name pattern", pEx.getMessage());
}
}
-
+
public void testParseBadPattern2() {
PatternParser p = new PatternParser("Foo");
AnnotationTypePattern bad = p.maybeParseAnnotationPattern();
- assertEquals("ANY",AnnotationTypePattern.ANY,bad);
+ assertEquals("ANY", AnnotationTypePattern.ANY, bad);
}
public void testParseNameOrVarAnnotationPattern() {
PatternParser p = new PatternParser("Foo");
AnnotationTypePattern foo = p.parseAnnotationNameOrVarTypePattern();
- assertTrue("ExactAnnotationTypePattern expected",foo!=null);
- assertEquals("Foo",UnresolvedType.forName("Foo"),((ExactAnnotationTypePattern)foo).annotationType);
+ assertTrue("ExactAnnotationTypePattern expected", foo != null);
+ assertEquals("Foo", UnresolvedType.forName("Foo"),
+ ((ExactAnnotationTypePattern) foo).annotationType);
}
-
+
public void testParseNameOrVarAnnotationPatternWithNot() {
PatternParser p = new PatternParser("!@Foo");
try {
-// AnnotationTypePattern bad =
- p.parseAnnotationNameOrVarTypePattern();
+ // AnnotationTypePattern bad =
+ p.parseAnnotationNameOrVarTypePattern();
fail("ParserException expected");
- } catch(ParserException pEx) {
- assertEquals("identifier",pEx.getMessage());
- }
+ } catch (ParserException pEx) {
+ assertEquals("identifier", pEx.getMessage());
+ }
}
public void testParseNameOrVarAnnotationPatternWithOr() {
PatternParser p = new PatternParser("Foo || Boo");
AnnotationTypePattern foo = p.parseAnnotationNameOrVarTypePattern();
// rest of pattern not consumed...
- assertTrue("ExactAnnotationTypePattern",foo instanceof ExactAnnotationTypePattern);
- assertEquals("Foo",UnresolvedType.forName("Foo"),((ExactAnnotationTypePattern)foo).annotationType);
+ assertTrue("ExactAnnotationTypePattern",
+ foo instanceof ExactAnnotationTypePattern);
+ assertEquals("Foo", UnresolvedType.forName("Foo"),
+ ((ExactAnnotationTypePattern) foo).annotationType);
}
-
+
public void testParseNameOrVarAnnotationWithBinding() {
PatternParser p = new PatternParser("foo");
AnnotationTypePattern foo = p.parseAnnotationNameOrVarTypePattern();
- assertTrue("ExactAnnotationTypePattern",foo instanceof ExactAnnotationTypePattern);
- assertEquals("@foo",((ExactAnnotationTypePattern)foo).toString());
+ assertTrue("ExactAnnotationTypePattern",
+ foo instanceof ExactAnnotationTypePattern);
+ assertEquals("@foo", ((ExactAnnotationTypePattern) foo).toString());
}
public void testParseNameOrVarAnnotationPatternWithAnd() {
PatternParser p = new PatternParser("Foo Boo");
AnnotationTypePattern foo = p.parseAnnotationNameOrVarTypePattern();
// rest of pattern not consumed...
- assertEquals("@Foo",foo.toString());
+ assertEquals("@Foo", foo.toString());
}
public void testMaybeParseAnnotationPattern() {
PatternParser p = new PatternParser("@Foo");
AnnotationTypePattern a = p.maybeParseAnnotationPattern();
- assertNotNull("Should find annotation pattern",a);
+ assertNotNull("Should find annotation pattern", a);
p = new PatternParser("Foo && Boo");
a = p.maybeParseAnnotationPattern();
- assertEquals("Should be ANY pattern for a non-match",AnnotationTypePattern.ANY,a);
+ assertEquals("Should be ANY pattern for a non-match",
+ AnnotationTypePattern.ANY, a);
}
-
+
public void testParseTypePatternsWithAnnotations() {
PatternParser p = new PatternParser("@Foo *");
TypePattern t = p.parseTypePattern();
- assertTrue("WildTypePattern",t instanceof WildTypePattern);
+ assertTrue("WildTypePattern", t instanceof WildTypePattern);
AnnotationTypePattern atp = t.annotationPattern;
- assertEquals("@(Foo)",atp.toString());
- assertEquals("(@(Foo) *)",t.toString());
+ assertEquals("@(Foo)", atp.toString());
+ assertEquals("(@(Foo) *)", t.toString());
}
-
+
public void testParseTypePatternsWithAnnotationsComplex() {
PatternParser p = new PatternParser("(@(Foo || Boo) (Foo || Boo))");
TypePattern t = p.parseTypePattern();
- assertTrue("OrTypePattern",t instanceof OrTypePattern);
- assertEquals("((@((Foo || Boo)) Foo) || (@((Foo || Boo)) Boo))",t.toString());
+ assertTrue("OrTypePattern", t instanceof OrTypePattern);
+ assertEquals("((@((Foo || Boo)) Foo) || (@((Foo || Boo)) Boo))", t
+ .toString());
}
-
+
public void testNotSyntax() {
PatternParser p = new PatternParser("!@Foo (Foo || Boo))");
TypePattern t = p.parseTypePattern();
- assertTrue("OrTypePattern",t instanceof OrTypePattern);
- assertEquals("((!@(Foo) Foo) || (!@(Foo) Boo))",t.toString());
+ assertTrue("OrTypePattern", t instanceof OrTypePattern);
+ assertEquals("((!@(Foo) Foo) || (!@(Foo) Boo))", t.toString());
}
public void testParseMethodOrConstructorSigNoAP() {
PatternParser p = new PatternParser("* *.*(..)");
SignaturePattern s = p.parseMethodOrConstructorSignaturePattern();
- assertEquals("Any annotation",AnnotationTypePattern.ANY,s.getAnnotationPattern());
- assertEquals("Any return","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("* *.*(..)",s.toString());
+ assertEquals("Any annotation", AnnotationTypePattern.ANY, s
+ .getAnnotationPattern());
+ assertEquals("Any return", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("* *.*(..)", s.toString());
}
-
+
public void testParseMethodOrConstructorSigSimpleAP() {
PatternParser p = new PatternParser("@Foo * *.*(..)");
SignaturePattern s = p.parseMethodOrConstructorSignaturePattern();
- assertEquals("@(Foo) annotation","@(Foo)",s.getAnnotationPattern().toString());
- assertEquals("Any return","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("@(Foo) * *.*(..)",s.toString());
+ assertEquals("@(Foo) annotation", "@(Foo)", s.getAnnotationPattern()
+ .toString());
+ assertEquals("Any return", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("@(Foo) * *.*(..)", s.toString());
}
-
+
public void testParseMethodOrConstructorSigComplexAP() {
PatternParser p = new PatternParser("!@(Foo || Goo) * *.*(..)");
SignaturePattern s = p.parseMethodOrConstructorSignaturePattern();
- assertEquals("complex annotation","!@((Foo || Goo))",s.getAnnotationPattern().toString());
- assertEquals("Any return","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("!@((Foo || Goo)) * *.*(..)",s.toString());
+ assertEquals("complex annotation", "!@((Foo || Goo))", s
+ .getAnnotationPattern().toString());
+ assertEquals("Any return", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("!@((Foo || Goo)) * *.*(..)", s.toString());
}
-
+
public void testParseMethodFieldSigNoAP() {
PatternParser p = new PatternParser("* *.*");
SignaturePattern s = p.parseFieldSignaturePattern();
- assertEquals("Any annotation",AnnotationTypePattern.ANY,s.getAnnotationPattern());
- assertEquals("Any field type","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("* *.*",s.toString());
+ assertEquals("Any annotation", AnnotationTypePattern.ANY, s
+ .getAnnotationPattern());
+ assertEquals("Any field type", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("* *.*", s.toString());
}
-
+
public void testParseFieldSigSimpleAP() {
PatternParser p = new PatternParser("@Foo * *.*");
SignaturePattern s = p.parseFieldSignaturePattern();
- assertEquals("@Foo annotation","@(Foo)",s.getAnnotationPattern().toString());
- assertEquals("Any field type","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("@(Foo) * *.*",s.toString());
+ assertEquals("@Foo annotation", "@(Foo)", s.getAnnotationPattern()
+ .toString());
+ assertEquals("Any field type", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("@(Foo) * *.*", s.toString());
}
-
+
public void testParseFieldSigComplexAP() {
PatternParser p = new PatternParser("!@(Foo || Goo) * *.*");
SignaturePattern s = p.parseFieldSignaturePattern();
- assertEquals("complex annotation","!@((Foo || Goo))",s.getAnnotationPattern().toString());
- assertEquals("Any field type","*",s.getReturnType().toString());
- assertEquals("Any dec type","*",s.getDeclaringType().toString());
- assertEquals("Any name","*",s.getName().toString());
- assertEquals("!@((Foo || Goo)) * *.*",s.toString());
+ assertEquals("complex annotation", "!@((Foo || Goo))", s
+ .getAnnotationPattern().toString());
+ assertEquals("Any field type", "*", s.getReturnType().toString());
+ assertEquals("Any dec type", "*", s.getDeclaringType().toString());
+ assertEquals("Any name", "*", s.getName().toString());
+ assertEquals("!@((Foo || Goo)) * *.*", s.toString());
}
-
+
public void testExactAnnotationPatternMatching() {
if (LangUtil.is15VMOrGreater()) {
- PatternParser p = new PatternParser("@Foo");
- AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
- ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[]{"Foo"});
- assertTrue("matches element with Foo",ap.matches(ae).alwaysTrue());
- AnnotatedElementImpl ae2 = new AnnotatedElementImpl(new String[]{"Boo"});
- assertTrue("does not match element with Boo",ap.matches(ae2).alwaysFalse());
+ PatternParser p = new PatternParser("@Foo");
+ AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
+ ap = ap.resolveBindings(makeSimpleScope(), new Bindings(3), true);
+ AnnotatedElementImpl ae = new AnnotatedElementImpl(
+ new String[] { "Foo" });
+ assertTrue("matches element with Foo", ap.matches(ae).alwaysTrue());
+ AnnotatedElementImpl ae2 = new AnnotatedElementImpl(
+ new String[] { "Boo" });
+ assertTrue("does not match element with Boo", ap.matches(ae2)
+ .alwaysFalse());
}
}
-
+
public void testBindingAnnotationPatternMatching() {
if (LangUtil.is15VMOrGreater()) {
- PatternParser p = new PatternParser("foo");
- AnnotationTypePattern ap = p.parseAnnotationNameOrVarTypePattern();
- try {
- ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- } catch(AbortException abEx) {
- assertEquals("Binding not supported in @pcds (1.5.0 M1 limitation): null",abEx.getMessage());
- }
- // uncomment these next lines once binding is supported
-// AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[]{"Foo"});
-// assertTrue("matches element with Foo",ap.matches(ae).alwaysTrue());
-// AnnotatedElementImpl ae2 = new AnnotatedElementImpl(new String[]{"Boo"});
-// assertTrue("does not match element with Boo",ap.matches(ae2).alwaysFalse());
+ PatternParser p = new PatternParser("foo");
+ AnnotationTypePattern ap = p.parseAnnotationNameOrVarTypePattern();
+ try {
+ ap = ap.resolveBindings(makeSimpleScope(), new Bindings(3),
+ true);
+ } catch (AbortException abEx) {
+ assertEquals(
+ "Binding not supported in @pcds (1.5.0 M1 limitation): null",
+ abEx.getMessage());
+ }
+ // uncomment these next lines once binding is supported
+ // AnnotatedElementImpl ae = new AnnotatedElementImpl(new
+ // String[]{"Foo"});
+ //assertTrue("matches element with Foo",ap.matches(ae).alwaysTrue())
+ // ;
+ // AnnotatedElementImpl ae2 = new AnnotatedElementImpl(new
+ // String[]{"Boo"});
+ // assertTrue("does not match element with Boo",ap.matches(ae2).
+ // alwaysFalse());
}
}
-
+
public void testAndAnnotationPatternMatching() {
if (LangUtil.is15VMOrGreater()) {
- PatternParser p = new PatternParser("@Foo @Boo");
- AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
- ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {"Foo","Boo"});
- assertTrue("matches foo and boo",ap.matches(ae).alwaysTrue());
- ae = new AnnotatedElementImpl(new String[] {"Foo"});
- assertTrue("does not match foo",ap.matches(ae).alwaysFalse());
- ae = new AnnotatedElementImpl(new String[] {"Boo"});
- assertTrue("does not match boo",ap.matches(ae).alwaysFalse());
- ae = new AnnotatedElementImpl(new String[] {"Goo"});
- assertTrue("does not match goo",ap.matches(ae).alwaysFalse());
+ PatternParser p = new PatternParser("@Foo @Boo");
+ AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
+ ap = ap.resolveBindings(makeSimpleScope(), new Bindings(3), true);
+ AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {
+ "Foo", "Boo" });
+ assertTrue("matches foo and boo", ap.matches(ae).alwaysTrue());
+ ae = new AnnotatedElementImpl(new String[] { "Foo" });
+ assertTrue("does not match foo", ap.matches(ae).alwaysFalse());
+ ae = new AnnotatedElementImpl(new String[] { "Boo" });
+ assertTrue("does not match boo", ap.matches(ae).alwaysFalse());
+ ae = new AnnotatedElementImpl(new String[] { "Goo" });
+ assertTrue("does not match goo", ap.matches(ae).alwaysFalse());
}
}
-//
-// public void testOrAnnotationPatternMatching() {
-// PatternParser p = new PatternParser("@Foo || @Boo");
-// AnnotationTypePattern ap = p.parseAnnotationTypePattern();
-// ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
-// AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {"Foo","Boo"});
-// assertTrue("matches foo and boo",ap.matches(ae).alwaysTrue());
-// ae = new AnnotatedElementImpl(new String[] {"Foo"});
-// assertTrue("matches foo",ap.matches(ae).alwaysTrue());
-// ae = new AnnotatedElementImpl(new String[] {"Boo"});
-// assertTrue("matches boo",ap.matches(ae).alwaysTrue());
-// ae = new AnnotatedElementImpl(new String[] {"Goo"});
-// assertTrue("does not match goo",ap.matches(ae).alwaysFalse());
-// }
-//
+
+ //
+ // public void testOrAnnotationPatternMatching() {
+ // PatternParser p = new PatternParser("@Foo || @Boo");
+ // AnnotationTypePattern ap = p.parseAnnotationTypePattern();
+ // ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
+ // AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[]
+ // {"Foo","Boo"});
+ // assertTrue("matches foo and boo",ap.matches(ae).alwaysTrue());
+ // ae = new AnnotatedElementImpl(new String[] {"Foo"});
+ // assertTrue("matches foo",ap.matches(ae).alwaysTrue());
+ // ae = new AnnotatedElementImpl(new String[] {"Boo"});
+ // assertTrue("matches boo",ap.matches(ae).alwaysTrue());
+ // ae = new AnnotatedElementImpl(new String[] {"Goo"});
+ // assertTrue("does not match goo",ap.matches(ae).alwaysFalse());
+ // }
+ //
public void testNotAnnotationPatternMatching() {
if (LangUtil.is15VMOrGreater()) {
- PatternParser p = new PatternParser("!@Foo");
- AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
- ap = ap.resolveBindings(makeSimpleScope(),new Bindings(3),true);
- AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {"Foo","Boo"});
- assertTrue("does not match foo and boo",ap.matches(ae).alwaysFalse());
- ae = new AnnotatedElementImpl(new String[] {"Boo"});
- assertTrue("matches boo",ap.matches(ae).alwaysTrue());
+ PatternParser p = new PatternParser("!@Foo");
+ AnnotationTypePattern ap = p.maybeParseAnnotationPattern();
+ ap = ap.resolveBindings(makeSimpleScope(), new Bindings(3), true);
+ AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {
+ "Foo", "Boo" });
+ assertTrue("does not match foo and boo", ap.matches(ae)
+ .alwaysFalse());
+ ae = new AnnotatedElementImpl(new String[] { "Boo" });
+ assertTrue("matches boo", ap.matches(ae).alwaysTrue());
}
}
-
+
public void testAnyAnnotationPatternMatching() {
- AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {"Foo","Boo"});
- assertTrue("always matches",AnnotationTypePattern.ANY.matches(ae).alwaysTrue());
+ AnnotatedElementImpl ae = new AnnotatedElementImpl(new String[] {
+ "Foo", "Boo" });
+ assertTrue("always matches", AnnotationTypePattern.ANY.matches(ae)
+ .alwaysTrue());
ae = new AnnotatedElementImpl(new String[] {});
- assertTrue("always matches",AnnotationTypePattern.ANY.matches(ae).alwaysTrue());
+ assertTrue("always matches", AnnotationTypePattern.ANY.matches(ae)
+ .alwaysTrue());
}
-
-
+
public TestScope makeSimpleScope() {
- BcelWorld bWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH + "/testcode.jar"); // testcode contains Foo/Boo/Goo/etc
+ BcelWorld bWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH
+ + "/testcode.jar"); // testcode contains Foo/Boo/Goo/etc
bWorld.setBehaveInJava5Way(true);
- return new TestScope(new String[] {"int", "java.lang.String","Foo","Boo","Goo"},
- new String[] {"a", "b","foo","boo","goo"},
- bWorld);
+ return new TestScope(new String[] { "int", "java.lang.String", "Foo",
+ "Boo", "Goo" }, new String[] { "a", "b", "foo", "boo", "goo" },
+ bWorld);
}
-
- // put test cases for AnnotationPatternList matching in separate test class...
-
+
+ // put test cases for AnnotationPatternList matching in separate test
+ // class...
+
static class AnnotatedElementImpl implements AnnotatedElement {
private String[] annotationTypes;
-
- public AnnotatedElementImpl(String[] annotationTypes) {
+
+ public AnnotatedElementImpl(String[] annotationTypes) {
this.annotationTypes = annotationTypes;
}
-
+
public boolean hasAnnotation(UnresolvedType ofType) {
for (int i = 0; i < annotationTypes.length; i++) {
- if (annotationTypes[i].equals(ofType.getName())) return true;
+ if (annotationTypes[i].equals(ofType.getName()))
+ return true;
}
return false;
}
-
- /* (non-Javadoc)
+
+ /*
+ * (non-Javadoc)
+ *
* @see org.aspectj.weaver.AnnotatedElement#getAnnotationTypes()
*/
public ResolvedType[] getAnnotationTypes() {
return null;
}
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
// TODO Auto-generated method stub
return null;
}
-
+
}
}
projects / aspectj.git / commitdiff