/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * All rights reserved. 
 * This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution and is available at 
 * http://www.eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: 
 *     PARC     initial implementation 
 * ******************************************************************/

package org.aspectj.weaver.patterns;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.aspectj.bridge.ISourceLocation;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
import org.aspectj.weaver.AnnotationTargetKind;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.JoinPointSignature;
import org.aspectj.weaver.JoinPointSignatureIterator;
import org.aspectj.weaver.Member;
import org.aspectj.weaver.MemberKind;
import org.aspectj.weaver.NewFieldTypeMunger;
import org.aspectj.weaver.ResolvableTypeList;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.VersionedDataInputStream;
import org.aspectj.weaver.World;

public class SignaturePattern extends PatternNode implements ISignaturePattern {
	private MemberKind kind;
	private ModifiersPattern modifiers;
	private TypePattern returnType;
	private TypePattern declaringType;
	private NamePattern name;
	private TypePatternList parameterTypes;
	private int bits = 0x0000;
	private static final int PARAMETER_ANNOTATION_MATCHING = 0x0001;
	private static final int CHECKED_FOR_PARAMETER_ANNOTATION_MATCHING = 0x0002;

	private ThrowsPattern throwsPattern;
	private AnnotationTypePattern annotationPattern;
	private transient int hashcode = -1;

	private transient boolean isExactDeclaringTypePattern = false;

	public SignaturePattern(MemberKind kind, ModifiersPattern modifiers, TypePattern returnType, TypePattern declaringType,
			NamePattern name, TypePatternList parameterTypes, ThrowsPattern throwsPattern, AnnotationTypePattern annotationPattern) {
		this.kind = kind;
		this.modifiers = modifiers;
		this.returnType = returnType;
		this.name = name;
		this.declaringType = declaringType;
		this.parameterTypes = parameterTypes;
		this.throwsPattern = throwsPattern;
		this.annotationPattern = annotationPattern;
		this.isExactDeclaringTypePattern = (declaringType instanceof ExactTypePattern);
	}

	@Override
	public SignaturePattern resolveBindings(IScope scope, Bindings bindings) {
		if (returnType != null) {
			returnType = returnType.resolveBindings(scope, bindings, false, false);
			checkForIncorrectTargetKind(returnType, scope, false);
		}
		if (declaringType != null) {
			declaringType = declaringType.resolveBindings(scope, bindings, false, false);
			checkForIncorrectTargetKind(declaringType, scope, false);
			isExactDeclaringTypePattern = (declaringType instanceof ExactTypePattern);
		}
		if (parameterTypes != null) {
			parameterTypes = parameterTypes.resolveBindings(scope, bindings, false, false);
			checkForIncorrectTargetKind(parameterTypes, scope, false, true);
		}
		if (throwsPattern != null) {
			throwsPattern = throwsPattern.resolveBindings(scope, bindings);
			if (throwsPattern.getForbidden().getTypePatterns().length > 0
					|| throwsPattern.getRequired().getTypePatterns().length > 0) {
				checkForIncorrectTargetKind(throwsPattern, scope, false);
			}
		}
		if (annotationPattern != null) {
			annotationPattern = annotationPattern.resolveBindings(scope, bindings, false);
			checkForIncorrectTargetKind(annotationPattern, scope, true);
		}
		hashcode = -1;
		return this;
	}

	private void checkForIncorrectTargetKind(PatternNode patternNode, IScope scope, boolean targetsOtherThanTypeAllowed) {
		checkForIncorrectTargetKind(patternNode, scope, targetsOtherThanTypeAllowed, false);

	}

	// bug 115252 - adding an xlint warning if the annnotation target type is
	// wrong. This logic, or similar, may have to be applied elsewhere in the case
	// of pointcuts which don't go through SignaturePattern.resolveBindings(..)
	private void checkForIncorrectTargetKind(PatternNode patternNode, IScope scope, boolean targetsOtherThanTypeAllowed,
			boolean parameterTargettingAnnotationsAllowed) {
		// return if we're not in java5 mode, if the unmatchedTargetKind Xlint
		// warning has been turned off, or if the patternNode is *
		if (!scope.getWorld().isInJava5Mode() || scope.getWorld().getLint().unmatchedTargetKind == null
				|| (patternNode instanceof AnyTypePattern)) {
			return;
		}
		if (patternNode instanceof ExactAnnotationTypePattern) {
			ResolvedType resolvedType = ((ExactAnnotationTypePattern) patternNode).getAnnotationType().resolve(scope.getWorld());
			if (targetsOtherThanTypeAllowed) {
				AnnotationTargetKind[] targetKinds = resolvedType.getAnnotationTargetKinds();
				if (targetKinds == null) {
					return;
				}
				reportUnmatchedTargetKindMessage(targetKinds, patternNode, scope, true);
			} else if (!targetsOtherThanTypeAllowed && !resolvedType.canAnnotationTargetType()) {
				// everything is incorrect since we've already checked whether we have the TYPE target annotation
				AnnotationTargetKind[] targetKinds = resolvedType.getAnnotationTargetKinds();
				if (targetKinds == null) {
					return;
				}
				reportUnmatchedTargetKindMessage(targetKinds, patternNode, scope, false);
			}
		} else {
			TypePatternVisitor visitor = new TypePatternVisitor(scope, targetsOtherThanTypeAllowed,
					parameterTargettingAnnotationsAllowed);
			patternNode.traverse(visitor, null);
			if (visitor.containedIncorrectTargetKind()) {
				Set<ExactAnnotationTypePattern> keys = visitor.getIncorrectTargetKinds().keySet();
				for (Iterator<ExactAnnotationTypePattern> iter = keys.iterator(); iter.hasNext();) {
					PatternNode node = iter.next();
					AnnotationTargetKind[] targetKinds = visitor.getIncorrectTargetKinds().get(node);
					reportUnmatchedTargetKindMessage(targetKinds, node, scope, false);
				}
			}
		}
	}

	private void reportUnmatchedTargetKindMessage(AnnotationTargetKind[] annotationTargetKinds, PatternNode node, IScope scope,
			boolean checkMatchesMemberKindName) {
		StringBuffer targetNames = new StringBuffer("{");
		for (int i = 0; i < annotationTargetKinds.length; i++) {
			AnnotationTargetKind targetKind = annotationTargetKinds[i];
			if (checkMatchesMemberKindName && kind.getName().equals(targetKind.getName())) {
				return;
			}
			if (i < (annotationTargetKinds.length - 1)) {
				targetNames.append("ElementType." + targetKind.getName() + ",");
			} else {
				targetNames.append("ElementType." + targetKind.getName() + "}");
			}
		}
		scope.getWorld().getLint().unmatchedTargetKind.signal(new String[] { node.toString(), targetNames.toString() },
				getSourceLocation(), new ISourceLocation[0]);
	}

	/**
	 * Class which visits the nodes in the TypePattern tree until an ExactTypePattern is found. Once this is found it creates a new
	 * ExactAnnotationTypePattern and checks whether the targetKind (created via the @Target annotation) matches ElementType.TYPE if
	 * this is the only target kind which is allowed, or matches the signature pattern kind if there is no restriction.
	 */
	private class TypePatternVisitor extends AbstractPatternNodeVisitor {

		private IScope scope;
		private Map<ExactAnnotationTypePattern, AnnotationTargetKind[]> incorrectTargetKinds = new HashMap<ExactAnnotationTypePattern, AnnotationTargetKind[]>();
		private boolean targetsOtherThanTypeAllowed;
		private boolean parameterTargettingAnnotationsAllowed;

		/**
		 * @param requiredTarget - the signature pattern Kind
		 * @param scope
		 * @param parameterTargettingAnnotationsAllowed
		 */
		public TypePatternVisitor(IScope scope, boolean targetsOtherThanTypeAllowed, boolean parameterTargettingAnnotationsAllowed) {
			this.scope = scope;
			this.targetsOtherThanTypeAllowed = targetsOtherThanTypeAllowed;
			this.parameterTargettingAnnotationsAllowed = parameterTargettingAnnotationsAllowed;
		}

		@Override
		public Object visit(WildAnnotationTypePattern node, Object data) {
			node.getTypePattern().accept(this, data);
			return node;
		}

		/**
		 * Do the ExactAnnotationTypePatterns have the incorrect target?
		 */
		@Override
		public Object visit(ExactAnnotationTypePattern node, Object data) {
			ResolvedType resolvedType = node.getAnnotationType().resolve(scope.getWorld());
			if (targetsOtherThanTypeAllowed) {
				AnnotationTargetKind[] targetKinds = resolvedType.getAnnotationTargetKinds();
				if (targetKinds == null) {
					return data;
				}
				List<AnnotationTargetKind> incorrectTargets = new ArrayList<AnnotationTargetKind>();
				for (int i = 0; i < targetKinds.length; i++) {
					if (targetKinds[i].getName().equals(kind.getName())
							|| (targetKinds[i].getName().equals("PARAMETER") && node.isForParameterAnnotationMatch())) {
						return data;
					}
					incorrectTargets.add(targetKinds[i]);
				}
				if (incorrectTargets.isEmpty()) {
					return data;
				}
				AnnotationTargetKind[] kinds = new AnnotationTargetKind[incorrectTargets.size()];
				incorrectTargetKinds.put(node, incorrectTargets.toArray(kinds));
			} else if (!targetsOtherThanTypeAllowed && !resolvedType.canAnnotationTargetType()) {
				AnnotationTargetKind[] targetKinds = resolvedType.getAnnotationTargetKinds();
				if (targetKinds == null) {
					return data;
				}
				// exception here is if parameter annotations are allowed
				if (parameterTargettingAnnotationsAllowed) {
					for (int i = 0; i < targetKinds.length; i++) {
						AnnotationTargetKind annotationTargetKind = targetKinds[i];
						if (annotationTargetKind.getName().equals("PARAMETER") && node.isForParameterAnnotationMatch()) {
							return data;
						}
					}
				}
				incorrectTargetKinds.put(node, targetKinds);
			}
			return data;
		}

		@Override
		public Object visit(ExactTypePattern node, Object data) {
			ExactAnnotationTypePattern eatp = new ExactAnnotationTypePattern(node.getExactType().resolve(scope.getWorld()), null);
			eatp.accept(this, data);
			return data;
		}

		@Override
		public Object visit(AndTypePattern node, Object data) {
			node.getLeft().accept(this, data);
			node.getRight().accept(this, data);
			return node;
		}

		@Override
		public Object visit(OrTypePattern node, Object data) {
			node.getLeft().accept(this, data);
			node.getRight().accept(this, data);
			return node;
		}

		@Override
		public Object visit(AnyWithAnnotationTypePattern node, Object data) {
			node.getAnnotationPattern().accept(this, data);
			return node;
		}

		public boolean containedIncorrectTargetKind() {
			return (incorrectTargetKinds.size() != 0);
		}

		public Map<ExactAnnotationTypePattern, AnnotationTargetKind[]> getIncorrectTargetKinds() {
			return incorrectTargetKinds;
		}
	}

	public void postRead(ResolvedType enclosingType) {
		if (returnType != null) {
			returnType.postRead(enclosingType);
		}
		if (declaringType != null) {
			declaringType.postRead(enclosingType);
		}
		if (parameterTypes != null) {
			parameterTypes.postRead(enclosingType);
		}
	}

	/**
	 * return a copy of this signature pattern in which every type variable reference is replaced by the corresponding entry in the
	 * map.
	 */
	@Override
	public SignaturePattern parameterizeWith(Map<String, UnresolvedType> typeVariableMap, World w) {
		SignaturePattern ret = new SignaturePattern(kind, modifiers, returnType.parameterizeWith(typeVariableMap, w), declaringType
				.parameterizeWith(typeVariableMap, w), name, parameterTypes.parameterizeWith(typeVariableMap, w), throwsPattern
				.parameterizeWith(typeVariableMap, w), annotationPattern.parameterizeWith(typeVariableMap, w));
		ret.copyLocationFrom(this);
		return ret;
	}

	@Override
	public boolean matches(Member joinPointSignature, World world, boolean allowBridgeMethods) {
		// fail (or succeed!) fast tests...
		if (joinPointSignature == null) {
			return false;
		}
		if (kind != joinPointSignature.getKind()) {
			return false;
		}
		if (kind == Member.ADVICE) {
			return true;
		}

		// do the hard work then...
		boolean subjectMatch = true;
		boolean wantsAnnotationMatch = wantToMatchAnnotationPattern();
		JoinPointSignatureIterator candidateMatches = joinPointSignature.getJoinPointSignatures(world);
		while (candidateMatches.hasNext()) {
			JoinPointSignature aSig = candidateMatches.next();
			// System.out.println(aSig);
			FuzzyBoolean matchResult = matchesExactly(aSig, world, allowBridgeMethods, subjectMatch);
			if (matchResult.alwaysTrue()) {
				return true;
			} else if (matchResult.alwaysFalse()) {
				return false;
			}
			// if we got a "MAYBE" it's worth looking at the other signatures
			// The first signature is the subject signature - and against it we must match modifiers/annotations/throws
			// see http://www.eclipse.org/aspectj/doc/next/adk15notebook/join-point-modifiers.html
			subjectMatch = false;
			// Early exit
			if (wantsAnnotationMatch) {
				return false;
			}
		}
		return false;
	}

	// Does this pattern match this exact signature (no declaring type mucking about
	// or chasing up the hierarchy)
	// return YES if it does, NO if it doesn't and no ancester member could match either,
	// and MAYBE if it doesn't but an ancester member could.
	private FuzzyBoolean matchesExactly(JoinPointSignature aMember, World inAWorld, boolean allowBridgeMethods, boolean subjectMatch) {
		// Java5 introduces bridge methods, we match a call to them but nothing else...
		if (aMember.isBridgeMethod() && !allowBridgeMethods) {
			return FuzzyBoolean.MAYBE;
		}

		// Only the subject is checked for modifiers
		// see http://www.eclipse.org/aspectj/doc/next/adk15notebook/join-point-modifiers.html
		if (subjectMatch && !modifiers.matches(aMember.getModifiers())) {
			return FuzzyBoolean.NO;
		}

		FuzzyBoolean matchesIgnoringAnnotations = FuzzyBoolean.YES;
		if (kind == Member.STATIC_INITIALIZATION) {
			matchesIgnoringAnnotations = matchesExactlyStaticInitialization(aMember, inAWorld);
		} else if (kind == Member.FIELD) {
			matchesIgnoringAnnotations = matchesExactlyField(aMember, inAWorld);
		} else if (kind == Member.METHOD) {
			matchesIgnoringAnnotations = matchesExactlyMethod(aMember, inAWorld, subjectMatch);
		} else if (kind == Member.CONSTRUCTOR) {
			matchesIgnoringAnnotations = matchesExactlyConstructor(aMember, inAWorld);
		}
		if (matchesIgnoringAnnotations.alwaysFalse()) {
			return FuzzyBoolean.NO;
		}

		// Only the subject is checked for annotations (239441/119749)
		// see http://www.eclipse.org/aspectj/doc/next/adk15notebook/join-point-modifiers.html
		if (subjectMatch) {
			// The annotations must match if specified
			if (!matchesAnnotations(aMember, inAWorld).alwaysTrue()) {
				return FuzzyBoolean.NO;
			} else {
				return matchesIgnoringAnnotations;
			}
		} else {
			// Unless they specified any annotation then it is a failure
			if (annotationPattern instanceof AnyAnnotationTypePattern) {
				return matchesIgnoringAnnotations;
			} else {
				return FuzzyBoolean.NO;
			}
		}

		// if (subjectMatch && !matchesAnnotations(aMember, inAWorld).alwaysTrue()) {
		// return FuzzyBoolean.NO;
		// } else {
		//			
		// return matchesIgnoringAnnotations;
		// }

	}

	private boolean wantToMatchAnnotationPattern() {
		return !(annotationPattern instanceof AnyAnnotationTypePattern);
	}

	/**
	 * Matches on declaring type
	 */
	private FuzzyBoolean matchesExactlyStaticInitialization(JoinPointSignature aMember, World world) {
		return FuzzyBoolean.fromBoolean(declaringType.matchesStatically(aMember.getDeclaringType().resolve(world)));
	}

	/**
	 * Matches on name, declaring type, field type
	 */
	private FuzzyBoolean matchesExactlyField(JoinPointSignature aField, World world) {
		if (!name.matches(aField.getName())) {
			return FuzzyBoolean.NO;
		}
		ResolvedType fieldDeclaringType = aField.getDeclaringType().resolve(world);
		if (!declaringType.matchesStatically(fieldDeclaringType)) {
			return FuzzyBoolean.MAYBE;
		}
		if (!returnType.matchesStatically(aField.getReturnType().resolve(world))) {
			// looking bad, but there might be parameterization to consider...
			if (!returnType.matchesStatically(aField.getGenericReturnType().resolve(world))) {
				// ok, it's bad.
				return FuzzyBoolean.MAYBE;
			}
		}
		// passed all the guards...
		return FuzzyBoolean.YES;
	}

	/**
	 * Quickly detect if the joinpoint absolutely cannot match becaused the method parameters at the joinpoint cannot match against
	 * this signature pattern.
	 * 
	 * @param methodJoinpoint the joinpoint to quickly match against
	 * @return true if it is impossible for the joinpoint to match this signature
	 */
	private boolean parametersCannotMatch(JoinPointSignature methodJoinpoint) {
		if (methodJoinpoint.isVarargsMethod()) {
			// just give up early (for now)
			return false;
		}

		int patternParameterCount = parameterTypes.size();

		if (patternParameterCount == 0 || parameterTypes.ellipsisCount == 0) {
			boolean equalCount = patternParameterCount == methodJoinpoint.getParameterTypes().length;

			// Quick rule: pattern specifies zero parameters, and joinpoint has parameters *OR*
			if (patternParameterCount == 0 && !equalCount) {
				return true;
			}

			// Quick rule: pattern doesn't specify ellipsis and there are a different number of parameters on the
			// method join point as compared with the pattern
			if (parameterTypes.ellipsisCount == 0 && !equalCount) {
				if (patternParameterCount > 0 && parameterTypes.get(patternParameterCount - 1).isVarArgs()) {
					return false;
				}
				return true;
			}
		}

		return false;
	}

	/**
	 * Matches on name, declaring type, return type, parameter types, throws types
	 */
	private FuzzyBoolean matchesExactlyMethod(JoinPointSignature aMethod, World world, boolean subjectMatch) {
		if (parametersCannotMatch(aMethod)) {
			// System.err.println("Parameter types pattern " + parameterTypes + " pcount: " + aMethod.getParameterTypes().length);
			return FuzzyBoolean.NO;
		}
		// OPTIMIZE only for exact match do the pattern match now? Otherwise defer it until other fast checks complete?
		if (!name.matches(aMethod.getName())) {
			return FuzzyBoolean.NO;
		}
		// Check the throws pattern
		if (subjectMatch && !throwsPattern.matches(aMethod.getExceptions(), world)) {
			return FuzzyBoolean.NO;
		}

		// '*' trivially matches everything, no need to check further
		if (!declaringType.isStar()) {
			if (!declaringType.matchesStatically(aMethod.getDeclaringType().resolve(world))) {
				return FuzzyBoolean.MAYBE;
			}
		}

		// '*' would match any return value
		if (!returnType.isStar()) {
			boolean b = returnType.isBangVoid();
			if (b) {
				String s = aMethod.getReturnType().getSignature();
				if (s.length() == 1 && s.charAt(0) == 'V') {
					// it is void, so not a match
					return FuzzyBoolean.NO;
				}
			} else {
				if (returnType.isVoid()) {
					String s = aMethod.getReturnType().getSignature();
					if (s.length() != 1 || s.charAt(0) != 'V') {
						// it is not void, so not a match
						return FuzzyBoolean.NO;
					}
				} else {
					if (!returnType.matchesStatically(aMethod.getReturnType().resolve(world))) {
						// looking bad, but there might be parameterization to consider...
						if (!returnType.matchesStatically(aMethod.getGenericReturnType().resolve(world))) {
							// ok, it's bad.
							return FuzzyBoolean.MAYBE;
						}
					}
				}
			}
		}

		// The most simple case: pattern is (..) will match anything
		if (parameterTypes.size() == 1 && parameterTypes.get(0).isEllipsis()) {
			return FuzzyBoolean.YES;
		}

		if (!parameterTypes.canMatchSignatureWithNParameters(aMethod.getParameterTypes().length)) {
			return FuzzyBoolean.NO;
		}

		// OPTIMIZE both resolution of these types and their annotations should be deferred - just pass down a world and do it lower
		// down
		// ResolvedType[] resolvedParameters = world.resolve(aMethod.getParameterTypes());

		ResolvableTypeList rtl = new ResolvableTypeList(world, aMethod.getParameterTypes());
		// Only fetch the parameter annotations if the pointcut is going to be matching on them
		ResolvedType[][] parameterAnnotationTypes = null;
		if (isMatchingParameterAnnotations()) {
			parameterAnnotationTypes = aMethod.getParameterAnnotationTypes();
			if (parameterAnnotationTypes != null && parameterAnnotationTypes.length == 0) {
				parameterAnnotationTypes = null;
			}
		}

		if (!parameterTypes.matches(rtl, TypePattern.STATIC, parameterAnnotationTypes).alwaysTrue()) {
			// It could still be a match based on the generic sig parameter types of a parameterized type
			if (!parameterTypes.matches(new ResolvableTypeList(world, aMethod.getGenericParameterTypes()), TypePattern.STATIC,
					parameterAnnotationTypes).alwaysTrue()) {
				return FuzzyBoolean.MAYBE;
				// It could STILL be a match based on the erasure of the parameter types??
				// to be determined via test cases...
			}
		}

		// check that varargs specifications match
		if (!matchesVarArgs(aMethod, world)) {
			return FuzzyBoolean.MAYBE;
		}

		// passed all the guards..
		return FuzzyBoolean.YES;
	}

	/**
	 * Determine if any pattern in the parameter type pattern list is attempting to match on parameter annotations.
	 * 
	 * @return true if a parameter type pattern wants to match on a parameter annotation
	 */
	private boolean isMatchingParameterAnnotations() {
		if ((bits & CHECKED_FOR_PARAMETER_ANNOTATION_MATCHING) == 0) {
			bits |= CHECKED_FOR_PARAMETER_ANNOTATION_MATCHING;
			for (int tp = 0, max = parameterTypes.size(); tp < max; tp++) {
				TypePattern typePattern = parameterTypes.get(tp);
				if (isParameterAnnotationMatching(typePattern)) {
					bits |= PARAMETER_ANNOTATION_MATCHING;
				}
			}
		}
		return (bits & PARAMETER_ANNOTATION_MATCHING) != 0;
	}

	/**
	 * Walk the simple structure of a type pattern and determine if any leaf node is involved in parameter annotation matching.
	 */
	private boolean isParameterAnnotationMatching(TypePattern tp) {
		if (tp instanceof OrTypePattern) {
			OrTypePattern orAtp = (OrTypePattern) tp;
			return (isParameterAnnotationMatching(orAtp.getLeft()) || isParameterAnnotationMatching(orAtp.getRight()));
		} else if (tp instanceof AndTypePattern) {
			AndTypePattern andAtp = (AndTypePattern) tp;
			return (isParameterAnnotationMatching(andAtp.getLeft()) || isParameterAnnotationMatching(andAtp.getRight()));
		} else if (tp instanceof NotTypePattern) {
			NotTypePattern notAtp = (NotTypePattern) tp;
			return (isParameterAnnotationMatching(notAtp.getNegatedPattern()));
		} else {
			AnnotationTypePattern atp = tp.getAnnotationPattern();
			return isParameterAnnotationMatching(atp);
		}
	}

	private boolean isParameterAnnotationMatching(AnnotationTypePattern tp) {
		if (tp instanceof OrAnnotationTypePattern) {
			OrAnnotationTypePattern orAtp = (OrAnnotationTypePattern) tp;
			return (isParameterAnnotationMatching(orAtp.getLeft()) || isParameterAnnotationMatching(orAtp.getRight()));
		} else if (tp instanceof AndAnnotationTypePattern) {
			AndAnnotationTypePattern andAtp = (AndAnnotationTypePattern) tp;
			return (isParameterAnnotationMatching(andAtp.getLeft()) || isParameterAnnotationMatching(andAtp.getRight()));
		} else if (tp instanceof NotAnnotationTypePattern) {
			NotAnnotationTypePattern notAtp = (NotAnnotationTypePattern) tp;
			return (isParameterAnnotationMatching(notAtp.negatedPattern));
		} else {
			return tp.isForParameterAnnotationMatch();
		}
	}

	/**
	 * match on declaring type, parameter types, throws types
	 */
	private FuzzyBoolean matchesExactlyConstructor(JoinPointSignature aConstructor, World world) {
		if (!declaringType.matchesStatically(aConstructor.getDeclaringType().resolve(world))) {
			return FuzzyBoolean.NO;
		}

		if (!parameterTypes.canMatchSignatureWithNParameters(aConstructor.getParameterTypes().length)) {
			return FuzzyBoolean.NO;
		}
		ResolvedType[] resolvedParameters = world.resolve(aConstructor.getParameterTypes());

		ResolvedType[][] parameterAnnotationTypes = aConstructor.getParameterAnnotationTypes();

		if (parameterAnnotationTypes == null || parameterAnnotationTypes.length == 0) {
			parameterAnnotationTypes = null;
		}

		if (!parameterTypes.matches(resolvedParameters, TypePattern.STATIC, parameterAnnotationTypes).alwaysTrue()) {
			// It could still be a match based on the generic sig parameter types of a parameterized type
			if (!parameterTypes.matches(world.resolve(aConstructor.getGenericParameterTypes()), TypePattern.STATIC, parameterAnnotationTypes).alwaysTrue()) {
				return FuzzyBoolean.MAYBE;
				// It could STILL be a match based on the erasure of the parameter types??
				// to be determined via test cases...
			}
		}

		// check that varargs specifications match
		if (!matchesVarArgs(aConstructor, world)) {
			return FuzzyBoolean.NO;
		}

		// Check the throws pattern
		if (!throwsPattern.matches(aConstructor.getExceptions(), world)) {
			return FuzzyBoolean.NO;
		}

		// passed all the guards..
		return FuzzyBoolean.YES;
	}

	/**
	 * We've matched against this method or constructor so far, but without considering varargs (which has been matched as a simple
	 * array thus far). Now we do the additional checks to see if the parties agree on whether the last parameter is varargs or a
	 * straight array.
	 */
	private boolean matchesVarArgs(JoinPointSignature aMethodOrConstructor, World inAWorld) {
		if (parameterTypes.size() == 0) {
			return true;
		}

		TypePattern lastPattern = parameterTypes.get(parameterTypes.size() - 1);
		boolean canMatchVarArgsSignature = lastPattern.isStar() || lastPattern.isVarArgs() || (lastPattern == TypePattern.ELLIPSIS);

		if (aMethodOrConstructor.isVarargsMethod()) {
			// we have at least one parameter in the pattern list, and the method has a varargs signature
			if (!canMatchVarArgsSignature) {
				// XXX - Ideally the shadow would be included in the msg but we don't know it...
				inAWorld.getLint().cantMatchArrayTypeOnVarargs.signal(aMethodOrConstructor.toString(), getSourceLocation());
				return false;
			}
		} else {
			// the method ends with an array type, check that we don't *require* a varargs
			if (lastPattern.isVarArgs()) {
				return false;
			}
		}

		return true;
	}

	private FuzzyBoolean matchesAnnotations(ResolvedMember member, World world) {
		if (member == null) {
			// world.getLint().unresolvableMember.signal(member.toString(), getSourceLocation());
			return FuzzyBoolean.NO;
		}
		annotationPattern.resolve(world);

		// optimization before we go digging around for annotations on ITDs
		if (annotationPattern instanceof AnyAnnotationTypePattern) {
			return FuzzyBoolean.YES;
		}

		// fake members represent ITD'd fields - for their annotations we should go and look up the
		// relevant member in the original aspect
		if (member.isAnnotatedElsewhere() && member.getKind() == Member.FIELD) {
			// FIXME asc duplicate of code in AnnotationPointcut.matchInternal()? same fixmes apply here.
			// ResolvedMember [] mems = member.getDeclaringType().resolve(world).getDeclaredFields(); // FIXME asc should include
			// supers with getInterTypeMungersIncludingSupers?
			List<ConcreteTypeMunger> mungers = member.getDeclaringType().resolve(world).getInterTypeMungers();
			for (ConcreteTypeMunger typeMunger : mungers) {
				if (typeMunger.getMunger() instanceof NewFieldTypeMunger) {
					ResolvedMember fakerm = typeMunger.getSignature();
					ResolvedMember ajcMethod = AjcMemberMaker.interFieldInitializer(fakerm, typeMunger.getAspectType());
					ResolvedMember rmm = findMethod(typeMunger.getAspectType(), ajcMethod);
					if (fakerm.equals(member)) {
						member = rmm;
					}
				}
			}
		}

		if (annotationPattern.matches(member).alwaysTrue()) {
			return FuzzyBoolean.YES;
		} else {
			// do NOT look at ancestor members... only the subject can have an annotation match
			// see http://www.eclipse.org/aspectj/doc/next/adk15notebook/join-point-modifiers.html
			return FuzzyBoolean.NO;
		}
	}

	private ResolvedMember findMethod(ResolvedType aspectType, ResolvedMember ajcMethod) {
		ResolvedMember decMethods[] = aspectType.getDeclaredMethods();
		for (int i = 0; i < decMethods.length; i++) {
			ResolvedMember member = decMethods[i];
			if (member.equals(ajcMethod)) {
				return member;
			}
		}
		return null;
	}

	public boolean declaringTypeMatchAllowingForCovariance(Member member, UnresolvedType shadowDeclaringType, World world,
			TypePattern returnTypePattern, ResolvedType sigReturn) {

		ResolvedType onType = shadowDeclaringType.resolve(world);

		// fastmatch
		if (declaringType.matchesStatically(onType) && returnTypePattern.matchesStatically(sigReturn)) {
			return true;
		}

		Collection<ResolvedType> declaringTypes = member.getDeclaringTypes(world);

		boolean checkReturnType = true;
		// XXX Possible enhancement? Doesn't seem to speed things up
		// if (returnTypePattern.isStar()) {
		// if (returnTypePattern instanceof WildTypePattern) {
		// if (((WildTypePattern)returnTypePattern).getDimensions()==0) checkReturnType = false;
		// }
		// }

		// Sometimes that list includes types that don't explicitly declare the member we are after -
		// they are on the list because their supertype is on the list, that's why we use
		// lookupMethod rather than lookupMemberNoSupers()
		for (ResolvedType type : declaringTypes) {
			if (declaringType.matchesStatically(type)) {
				if (!checkReturnType) {
					return true;
				}
				ResolvedMember rm = type.lookupMethod(member);
				if (rm == null) {
					rm = type.lookupMethodInITDs(member); // It must be in here, or we have *real* problems
				}
				if (rm == null) {
					continue; // might be currently looking at the generic type and we need to continue searching in case we hit a
				}
				// parameterized version of this same type...
				UnresolvedType returnTypeX = rm.getReturnType();
				ResolvedType returnType = returnTypeX.resolve(world);
				if (returnTypePattern.matchesStatically(returnType)) {
					return true;
				}
			}
		}
		return false;
	}

	// private Collection getDeclaringTypes(Signature sig) {
	// List l = new ArrayList();
	// Class onType = sig.getDeclaringType();
	// String memberName = sig.getName();
	// if (sig instanceof FieldSignature) {
	// Class fieldType = ((FieldSignature)sig).getFieldType();
	// Class superType = onType;
	// while(superType != null) {
	// try {
	// Field f = (superType.getDeclaredField(memberName));
	// if (f.getType() == fieldType) {
	// l.add(superType);
	// }
	// } catch (NoSuchFieldException nsf) {}
	// superType = superType.getSuperclass();
	// }
	// } else if (sig instanceof MethodSignature) {
	// Class[] paramTypes = ((MethodSignature)sig).getParameterTypes();
	// Class superType = onType;
	// while(superType != null) {
	// try {
	// superType.getDeclaredMethod(memberName,paramTypes);
	// l.add(superType);
	// } catch (NoSuchMethodException nsm) {}
	// superType = superType.getSuperclass();
	// }
	// }
	// return l;
	// }

	public NamePattern getName() {
		return name;
	}

	public TypePattern getDeclaringType() {
		return declaringType;
	}

	public MemberKind getKind() {
		return kind;
	}

	@Override
	public String toString() {
		StringBuffer buf = new StringBuffer();

		if (annotationPattern != AnnotationTypePattern.ANY) {
			buf.append(annotationPattern.toString());
			buf.append(' ');
		}

		if (modifiers != ModifiersPattern.ANY) {
			buf.append(modifiers.toString());
			buf.append(' ');
		}

		if (kind == Member.STATIC_INITIALIZATION) {
			buf.append(declaringType.toString());
			buf.append(".<clinit>()");// FIXME AV - bad, cannot be parsed again
		} else if (kind == Member.HANDLER) {
			buf.append("handler(");
			buf.append(parameterTypes.get(0));
			buf.append(")");
		} else {
			if (!(kind == Member.CONSTRUCTOR)) {
				buf.append(returnType.toString());
				buf.append(' ');
			}
			if (declaringType != TypePattern.ANY) {
				buf.append(declaringType.toString());
				buf.append('.');
			}
			if (kind == Member.CONSTRUCTOR) {
				buf.append("new");
			} else {
				buf.append(name.toString());
			}
			if (kind == Member.METHOD || kind == Member.CONSTRUCTOR) {
				buf.append(parameterTypes.toString());
			}
			// FIXME AV - throws is not printed here, weird
		}
		return buf.toString();
	}

	@Override
	public boolean equals(Object other) {
		if (!(other instanceof SignaturePattern)) {
			return false;
		}
		SignaturePattern o = (SignaturePattern) other;
		return o.kind.equals(this.kind) && o.modifiers.equals(this.modifiers) && o.returnType.equals(this.returnType)
				&& o.declaringType.equals(this.declaringType) && o.name.equals(this.name)
				&& o.parameterTypes.equals(this.parameterTypes) && o.throwsPattern.equals(this.throwsPattern)
				&& o.annotationPattern.equals(this.annotationPattern);
	}

	@Override
	public int hashCode() {
		if (hashcode == -1) {
			hashcode = 17;
			hashcode = 37 * hashcode + kind.hashCode();
			hashcode = 37 * hashcode + modifiers.hashCode();
			hashcode = 37 * hashcode + returnType.hashCode();
			hashcode = 37 * hashcode + declaringType.hashCode();
			hashcode = 37 * hashcode + name.hashCode();
			hashcode = 37 * hashcode + parameterTypes.hashCode();
			hashcode = 37 * hashcode + throwsPattern.hashCode();
			hashcode = 37 * hashcode + annotationPattern.hashCode();
		}
		return hashcode;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		kind.write(s);
		modifiers.write(s);
		returnType.write(s);
		declaringType.write(s);
		name.write(s);
		parameterTypes.write(s);
		throwsPattern.write(s);
		annotationPattern.write(s);
		writeLocation(s);
	}

	public static SignaturePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
		// ISignaturePattern kind should already have been read by the time this read is entered
		MemberKind kind = MemberKind.read(s);
		ModifiersPattern modifiers = ModifiersPattern.read(s);
		TypePattern returnType = TypePattern.read(s, context);
		TypePattern declaringType = TypePattern.read(s, context);
		NamePattern name = NamePattern.read(s);
		TypePatternList parameterTypes = TypePatternList.read(s, context);
		ThrowsPattern throwsPattern = ThrowsPattern.read(s, context);

		AnnotationTypePattern annotationPattern = AnnotationTypePattern.ANY;

		if (s.getMajorVersion() >= AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
			annotationPattern = AnnotationTypePattern.read(s, context);
		}

		SignaturePattern ret = new SignaturePattern(kind, modifiers, returnType, declaringType, name, parameterTypes,
				throwsPattern, annotationPattern);
		ret.readLocation(context, s);
		return ret;
	}

	/**
	 * @return
	 */
	public ModifiersPattern getModifiers() {
		return modifiers;
	}

	/**
	 * @return
	 */
	public TypePatternList getParameterTypes() {
		return parameterTypes;
	}

	/**
	 * @return
	 */
	public TypePattern getReturnType() {
		return returnType;
	}

	/**
	 * @return
	 */
	public ThrowsPattern getThrowsPattern() {
		return throwsPattern;
	}

	/**
	 * return true if last argument in params is an Object[] but the modifiers say this method was declared with varargs
	 * (Object...). We shouldn't be matching if this is the case.
	 */
	// private boolean matchedArrayAgainstVarArgs(TypePatternList params,int modifiers) {
	// if (params.size()>0 && (modifiers & Constants.ACC_VARARGS)!=0) {
	// // we have at least one parameter in the pattern list, and the method has a varargs signature
	// TypePattern lastPattern = params.get(params.size()-1);
	// if (lastPattern.isArray() && !lastPattern.isVarArgs) return true;
	// }
	// return false;
	// }
	public AnnotationTypePattern getAnnotationPattern() {
		return annotationPattern;
	}

	@Override
	public boolean isStarAnnotation() {
		return annotationPattern == AnnotationTypePattern.ANY;
	}

	@Override
	public Object accept(PatternNodeVisitor visitor, Object data) {
		return visitor.visit(this, data);
	}

	public boolean isExactDeclaringTypePattern() {
		return isExactDeclaringTypePattern;
	}

	@Override
	public boolean isMatchOnAnyName() {
		return getName().isAny();
	}

	@Override
	public List<ExactTypePattern> getExactDeclaringTypes() {
		if (declaringType instanceof ExactTypePattern) {
			List<ExactTypePattern> l = new ArrayList<ExactTypePattern>();
			l.add((ExactTypePattern) declaringType);
			return l;
		} else {
			return Collections.emptyList();
		}
	}

	@Override
	public boolean couldEverMatch(ResolvedType type) {
		return declaringType.matches(type, TypePattern.STATIC).maybeTrue();
	}

}
