Relates to #24.
Signed-off-by: Alexander Kriegisch <Alexander@Kriegisch.name>
return left.matchesStatically(type) && right.matchesStatically(type);
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return left.matchesArray(type) && right.matchesArray(type);
+ }
+
@Override
public void setIsVarArgs(boolean isVarArgs) {
this.isVarArgs = isVarArgs;
return FuzzyBoolean.YES;
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return true;
+ }
+
@Override
public void write(CompressingDataOutputStream s) throws IOException {
s.writeByte(ANY_KEY);
return FuzzyBoolean.MAYBE;
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return true;
+ }
+
@Override
public TypePattern parameterizeWith(Map<String,UnresolvedType> typeVariableMap, World w) {
AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(this.annotationPattern.parameterizeWith(
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ResolvedType;
+import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.World;
public class EllipsisTypePattern extends TypePattern {
return FuzzyBoolean.NO;
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return false;
+ }
+
@Override
public void write(CompressingDataOutputStream s) throws IOException {
s.writeByte(ELLIPSIS_KEY);
return (typeMatch && annMatch);
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return type.getDimensions() == getDimensions();
+ }
+
public UnresolvedType getType() {
return type;
}
import org.aspectj.weaver.Member;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;
+import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.VersionedDataInputStream;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.World;
return matchesExactly(type);
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return true;
+ }
+
@Override
public FuzzyBoolean matchesInstanceof(ResolvedType type) {
throw new UnsupportedOperationException("hasmethod/field do not support instanceof matching");
return false;
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return false;
+ }
+
/**
* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(ResolvedType)
*/
return (!negatedPattern.matchesExactly(type, annotatedType) && annotationPattern.matches(annotatedType).alwaysTrue());
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return !negatedPattern.matchesArray(type);
+ }
+
@Override
public boolean matchesStatically(ResolvedType type) {
return !negatedPattern.matchesStatically(type);
return left.matchesExactly(type, annotatedType) || right.matchesExactly(type, annotatedType);
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return left.matchesArray(type) || right.matchesArray(type);
+ }
+
public boolean matchesStatically(ResolvedType type) {
return left.matchesStatically(type) || right.matchesStatically(type);
}
* Matches on name, declaring type, return type, parameter types, throws types
*/
private FuzzyBoolean matchesExactlyMethod(JoinPointSignature aMethod, World world, boolean subjectMatch) {
- if (aMethod.getReturnType().getDimensions() != returnType.getDimensions()) {
+ if (!returnType.matchesArray(aMethod.getReturnType())) {
return FuzzyBoolean.NO;
}
if (parametersCannotMatch(aMethod)) {
return isRightCategory(type);
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return true;
+ }
+
@Override
public FuzzyBoolean matchesInstanceof(ResolvedType type) {
return FuzzyBoolean.fromBoolean(isRightCategory(type));
protected abstract boolean matchesExactly(ResolvedType type, ResolvedType annotatedType);
- protected boolean matchesArray(ResolvedType type) {
- return type.getDimensions() == getDimensions();
- }
+ protected abstract boolean matchesArray(UnresolvedType type);
protected boolean matchesSubtypes(ResolvedType type) {
// System.out.println("matching: " + this + " to " + type);
// Ensure the annotation pattern is resolved
annotationPattern.resolve(type.getWorld());
- return matchesExactlyByName(targetTypeName, type.isAnonymous(), type.isNested()) && matchesParameters(type, STATIC)
+ return matchesExactlyByName(targetTypeName.replaceFirst("(\\[\\])+$", ""), type.isAnonymous(), type.isNested()) && matchesParameters(type, STATIC)
&& matchesArray(type)
&& matchesBounds(type, STATIC)
&& annotationPattern.matches(annotatedType, type.temporaryAnnotationTypes).alwaysTrue();
return true;
}
+ @Override
+ protected boolean matchesArray(UnresolvedType type) {
+ return type.getDimensions() == getDimensions() ||
+ getDimensions() == 0 && namePatterns.length > 0 && namePatterns[namePatterns.length-1].toString().endsWith("*");
+ }
+
// we've matched against the base (or raw) type, but if this type pattern specifies bounds because
// it is a ? extends or ? super deal then we have to match them too.
private boolean matchesBounds(ResolvedType aType, MatchKind staticOrDynamic) {
return innerMatchesExactly(targetTypeName, isAnonymous, isNested);
}
- if (isNamePatternStar()) {
- // we match if the dimensions match
- int numDimensionsInTargetType = 0;
- if (dim > 0) {
- int index;
- while ((index = targetTypeName.indexOf('[')) != -1) {
- numDimensionsInTargetType++;
- targetTypeName = targetTypeName.substring(index + 1);
- }
- return numDimensionsInTargetType == dim;
- }
- }
-
// if our pattern is length 1, then known matches are exact matches
// if it's longer than that, then known matches are prefixes of a sort
if (namePatterns.length == 1) {
}
}
- return innerMatchesExactly(targetTypeName.substring(0, targetTypeName.length() - dim * 2), isAnonymous, isNested);
+ return innerMatchesExactly(targetTypeName, isAnonymous, isNested);
}
private int lastIndexOfDotOrDollar(String string) {
projects / aspectj.git / commitdiff