//XXX make sure this is applied to classes and interfaces
public void checkPointcutDeclarations() {
ResolvedMember[] pointcuts = getDeclaredPointcuts();
+ boolean sawError = false;
for (int i=0, len=pointcuts.length; i < len; i++) {
if (pointcuts[i].isAbstract()) {
if (!this.isAspect()) {
- MessageUtil.error(
- "abstract pointcut only allowed in aspect" + pointcuts[i].getName(),
- pointcuts[i].getSourceLocation());
+ eclipseWorld().showMessage(IMessage.ERROR,
+ "abstract pointcut only allowed in aspect" + pointcuts[i].getName(),
+ pointcuts[i].getSourceLocation(), null);
+ sawError = true;
} else if (!this.isAbstract()) {
- MessageUtil.error(
- "abstract pointcut in concrete aspect" + pointcuts[i].getName(),
- pointcuts[i].getSourceLocation());
+ eclipseWorld().showMessage(IMessage.ERROR,
+ "abstract pointcut in concrete aspect" + pointcuts[i],
+ pointcuts[i].getSourceLocation(), null);
+ sawError = true;
}
}
for (int j=i+1; j < len; j++) {
if (pointcuts[i].getName().equals(pointcuts[j].getName())) {
- eclipseWorld().getMessageHandler().handleMessage(
- MessageUtil.error(
- "duplicate pointcut name: " + pointcuts[j].getName(),
- pointcuts[j].getSourceLocation()));
+ eclipseWorld().showMessage(IMessage.ERROR,
+ "duplicate pointcut name: " + pointcuts[j].getName(),
+ pointcuts[i].getSourceLocation(), pointcuts[j].getSourceLocation());
+ sawError = true;
}
}
}
//now check all inherited pointcuts to be sure that they're handled reasonably
- if (!isAspect()) return;
+ if (sawError || !isAspect()) return;
String packageName =
new String(CharOperation.concatWith(cuScope.currentPackageName, '.'));
- if (packageName.length() > 1) {
+ //System.err.println("package: " + packageName);
+ if (packageName.length() > 0) {
importedPrefixesList.add(packageName + ".");
}
import java.util.*;
+import org.aspectj.bridge.*;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.weaver.patterns.*;
public boolean match(Shadow shadow, World world) {
if (super.match(shadow, world)) {
+ if (shadow.getKind() == Shadow.ExceptionHandler) {
+ if (kind.isAfter() || kind == AdviceKind.Around) {
+ world.showMessage(IMessage.WARNING,
+ "Only before advice is supported on handler join points (compiler limitation)",
+ getSourceLocation(), shadow.getSourceLocation());
+ return false;
+ }
+ }
+
+
if (hasExtraParameter() && kind == AdviceKind.AfterReturning) {
return getExtraParameterType().isConvertableFrom(shadow.getReturnType(), world);
} else if (kind == AdviceKind.PerTargetEntry) {
return shadow.hasThis();
} else if (kind == AdviceKind.Around) {
if (shadow.getKind() == Shadow.PreInitialization) {
- world.getMessageHandler().handleMessage(
- MessageUtil.error("Around on pre-initialization not supported in 1.1",
- getSourceLocation()));
- world.getMessageHandler().handleMessage(
- MessageUtil.error("Around on pre-initialization not supported in 1.1",
- shadow.getSourceLocation()));
+ world.showMessage(IMessage.WARNING,
+ "around on pre-initialization not supported (compiler limitation)",
+ getSourceLocation(), shadow.getSourceLocation());
return false;
} else {
if (!getSignature().getReturnType().isConvertableFrom(shadow.getReturnType(), world)) {
}
public ShadowMunger concretize(ResolvedTypeX fromType, World world, PerClause clause) {
- pointcut = pointcut.concretize(fromType, 0);
+ pointcut = pointcut.concretize(fromType, 0, this);
return this;
}
}
private void addShadowMunger(ShadowMunger m) {
- //if (inAspect.isAbstract()) return; // we don't do mungers for abstract aspects
+ if (inAspect.isAbstract()) return; // we don't do mungers for abstract aspects
addConcreteShadowMunger(m.concretize(inAspect, world, perClause));
}
public class IntMap {
public static final IntMap EMPTY = new IntMap(0) {
public boolean directlyInAdvice() { return true; }
- public Advice getEnclosingAdvice() { return null; } //XXX possible
+ public ShadowMunger getEnclosingAdvice() { return null; } //XXX possible
};
// XXX begin hack to avoid a signature refactoring in Pointcut
- private Advice enclosingAdvice;
+ private ResolvedTypeX concreteAspect;
+ private ShadowMunger enclosingAdvice;
private List/*ResolvedPointcutDefinition*/ enclosingDefinition = new ArrayList();
public void pushEnclosingDefinition(ResolvedPointcutDefinition def) {
return enclosingDefinition.isEmpty();
}
- public Advice getEnclosingAdvice() {
+ public ShadowMunger getEnclosingAdvice() {
return enclosingAdvice;
}
- public void setEnclosingAdvice(Advice advice) {
+ public void setEnclosingAdvice(ShadowMunger advice) {
this.enclosingAdvice = advice;
}
public Member getAdviceSignature() {
- return getEnclosingAdvice().signature;
+ if (enclosingAdvice instanceof Advice) return ((Advice)enclosingAdvice).signature;
+ else return null;
+ }
+
+
+ public ResolvedTypeX getConcreteAspect() {
+ return concreteAspect;
+ }
+
+ public void setConcreteAspect(ResolvedTypeX concreteAspect) {
+ this.concreteAspect = concreteAspect;
}
public void copyContext(IntMap bindings) {
this.enclosingAdvice = bindings.enclosingAdvice;
this.enclosingDefinition = bindings.enclosingDefinition;
+ this.concreteAspect = bindings.concreteAspect;
}
// XXX end hack to avoid a signature refactoring in Pointcut
}
+
}
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("poincut ");
+ buf.append(getDeclaringType().getName());
+ buf.append(".");
buf.append(getName());
buf.append("(");
for (int i=0; i < getParameterTypes().length; i++) {
if (i > 0) buf.append(", ");
buf.append(getParameterTypes()[i].toString());
}
- buf.append("): ");
- buf.append(pointcut);
+ buf.append(")");
+ //buf.append(pointcut);
return buf.toString();
}
new ResolvedPointcutDefinition(TypeX.OBJECT, 0, "missing",
TypeX.NONE, Pointcut.makeMatchesNothing(Pointcut.RESOLVED));
-
}
public List getExposedPointcuts() {
List ret = new ArrayList();
if (getSuperclass() != null) ret.addAll(getSuperclass().getExposedPointcuts());
-
-
for (Iterator i = Arrays.asList(getDeclaredInterfaces()).iterator(); i.hasNext(); ) {
ResolvedTypeX t = (ResolvedTypeX)i.next();
if (inherited.isAbstract()) {
if (!this.isAbstract()) {
getWorld().showMessage(IMessage.ERROR,
- "inherited abstract pointcut " + inherited +
+ "inherited abstract pointcut " + inherited.getSignature() +
" is not made concrete in " + this.getName(),
inherited.getSourceLocation(), this.getSourceLocation());
}
+ public Pointcut getPointcut() {
+ return pointcut;
+ }
+
}
Pointcut concreteEntry;
- CrosscuttingMembers xcut = inAspect.crosscuttingMembers;
+ CrosscuttingMembers xcut = bindings.getConcreteAspect().crosscuttingMembers;
Collection previousCflowEntries = xcut.getCflowEntries();
entryBindings.pushEnclosingDefinition(CFLOW_MARKER);
// add field and initializer to inAspect
//XXX and then that info above needs to be mapped down here to help with
//XXX getting the exposed state right
- inAspect.crosscuttingMembers.addConcreteShadowMunger(
+ bindings.getConcreteAspect().crosscuttingMembers.addConcreteShadowMunger(
Advice.makeCflowEntry(world, concreteEntry, isBelow, cflowField, freeVars.length, innerCflowEntries));
- inAspect.crosscuttingMembers.addTypeMunger(
+ bindings.getConcreteAspect().crosscuttingMembers.addTypeMunger(
world.makeCflowStackFieldAdder(cflowField));
IfPointcut ret = new IfPointcut(testMethod, extraParameterFlags);
partiallyConcretized = ret;
if (bindings.directlyInAdvice()) {
- Advice advice = bindings.getEnclosingAdvice();
- ret.baseArgsCount = advice.getBaseParameterCount();
+ ShadowMunger advice = bindings.getEnclosingAdvice();
+ ret.baseArgsCount = ((Advice)advice).getBaseParameterCount();
ret.residueSource = advice.getPointcut().concretize(inAspect, ret.baseArgsCount, advice);
} else {
ResolvedPointcutDefinition def = bindings.peekEnclosingDefinitition();
CrosscuttingMembers xcut = inAspect.crosscuttingMembers;
Collection previousCflowEntries = xcut.getCflowEntries();
- Pointcut concreteEntry = entry.concretize(inAspect, IntMap.EMPTY);
+ Pointcut concreteEntry = entry.concretize(inAspect, 0, null); //IntMap.EMPTY);
List innerCflowEntries = new ArrayList(xcut.getCflowEntries());
innerCflowEntries.removeAll(previousCflowEntries);
World world = inAspect.getWorld();
- Pointcut concreteEntry = entry.concretize(inAspect, IntMap.EMPTY);
+ Pointcut concreteEntry = entry.concretize(inAspect, 0, null);
//concreteEntry = new AndPointcut(this, concreteEntry);
//concreteEntry.state = Pointcut.CONCRETE;
inAspect.crosscuttingMembers.addConcreteShadowMunger(
//XXX this is the signature we're moving to
- public Pointcut concretize(ResolvedTypeX inAspect, int arity, Advice advice) {
+ public Pointcut concretize(ResolvedTypeX inAspect, int arity, ShadowMunger advice) {
//if (state == CONCRETE) return this; //???
IntMap map = IntMap.idMap(arity);
map.setEnclosingAdvice(advice);
+ map.setConcreteAspect(inAspect);
return concretize(inAspect, map);
}
);
return Pointcut.makeMatchesNothing(Pointcut.CONCRETE);
}
+
+ if (pointcutDec.isAbstract()) {
+ Thread.currentThread().dumpStack();
+ searchStart.getWorld().showMessage(IMessage.ERROR,
+ pointcutDec + " is abstract",
+ getSourceLocation(), bindings.getEnclosingAdvice().getSourceLocation());
+ return Pointcut.makeMatchesNothing(Pointcut.CONCRETE);
+ }
//System.err.println("start: " + searchStart);
ResolvedTypeX[] parameterTypes = searchStart.getWorld().resolve(pointcutDec.getParameterTypes());
projects / aspectj.git / commitdiff