Attachment #183097 for bug #329268




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

public abstract class AbstractBooleanTypePattern extends TypePattern {

	private TypePattern left;
	private TypePattern right;

	AbstractBooleanTypePattern(AST ast, TypePattern left, TypePattern right,
			String booleanOperator) {
		super(ast, booleanOperator);
		this.left = left;
		this.right = right;
	}

	public TypePattern getLeft() {
		return left;
	}

	public TypePattern getRight() {
		return right;
	}

	int treeSize() {
		return memSize() + (this.left == null ? 0 : getLeft().treeSize())
				+ (this.right == null ? 0 : getRight().treeSize());
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * 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

				((DeclareAtTypeDeclaration) declareDeclaration).setAnnotationName(annotationName);
			} else if (da.getKind().equals(DeclareAnnotation.AT_CONSTRUCTOR)) {
				declareDeclaration = new DeclareAtConstructorDeclaration(this.ast);
				((DeclareAtConstructorDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
				SimpleName annotationName = new SimpleName(this.ast);
				annotationName.setSourceRange(da.getAnnotationSourceStart(),
						da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());

				((DeclareAtConstructorDeclaration) declareDeclaration).setAnnotationName(annotationName);
			} else if (da.getKind().equals(DeclareAnnotation.AT_FIELD)) {
				declareDeclaration = new DeclareAtFieldDeclaration(this.ast);
				((DeclareAtFieldDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
				SimpleName annotationName = new SimpleName(this.ast);
				annotationName.setSourceRange(da.getAnnotationSourceStart(),
						da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());

				((DeclareAtFieldDeclaration) declareDeclaration).setAnnotationName(annotationName);
			} else if (da.getKind().equals(DeclareAnnotation.AT_METHOD)) {
				declareDeclaration = new DeclareAtMethodDeclaration(this.ast);
				((DeclareAtMethodDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
				SimpleName annotationName = new SimpleName(this.ast);
				annotationName.setSourceRange(da.getAnnotationSourceStart(),
						da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());

						.setTypePattern((org.aspectj.org.eclipse.jdt.core.dom.TypePattern) pNode);
			}
		}
		
		if (declareDeclaration != null) {
			declareDeclaration.setSourceRange(declareDecl.declarationSourceStart, declareDecl.declarationSourceEnd
					- declareDecl.declarationSourceStart + 1);
		}
		return declareDeclaration;
	}


		return pointcutDesi;
	}

	public org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern convertSignature(ISignaturePattern patternNode) {
		org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern pNode = null;
		if (patternNode instanceof SignaturePattern) {
			SignaturePattern sigPat = (SignaturePattern) patternNode;
			pNode = new org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern(this.ast, sigPat.toString());

		return pNode;
	}

	public org.aspectj.org.eclipse.jdt.core.dom.PatternNode convert(
			PatternNode patternNode) {
		// the different weaver TypePattern's
		org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = null;
		if (patternNode instanceof TypePattern) {
			TypePattern weaverTypePattern = (TypePattern) patternNode;
			return convert(weaverTypePattern);

		} else if (patternNode instanceof SignaturePattern) {
			SignaturePattern sigPat = (SignaturePattern) patternNode;
			pNode = new org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern(this.ast, sigPat.toString());


	}

	public org.aspectj.org.eclipse.jdt.core.dom.TypePattern convert(
			TypePattern weaverNode) {

		// First check if the node is a Java type (WildType, ExactType,
		// BindingType)
		org.aspectj.org.eclipse.jdt.core.dom.TypePattern domNode = createIdentifierTypePattern(weaverNode);

		if (domNode == null) {
			if (weaverNode instanceof org.aspectj.weaver.patterns.EllipsisTypePattern) {
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.EllipsisTypePattern(
						ast);
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.NoTypePattern) {
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.NoTypePattern(
						ast);
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.AnyTypePattern) {
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern(
						ast);
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.AnyWithAnnotationTypePattern) {
				// For now construct the node with just the annotation
				// expression
				String annotationExpression = ((org.aspectj.weaver.patterns.AnyWithAnnotationTypePattern) weaverNode)
						.toString();
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern(
						ast, annotationExpression);

			} else if (weaverNode instanceof org.aspectj.weaver.patterns.OrTypePattern) {
				org.aspectj.weaver.patterns.OrTypePattern compilerOrNode = (org.aspectj.weaver.patterns.OrTypePattern) weaverNode;
				domNode = new OrTypePattern(this.ast,
						convert(compilerOrNode.getLeft()),
						convert(compilerOrNode.getRight()));
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.AndTypePattern) {
				org.aspectj.weaver.patterns.AndTypePattern compilerAndType = (org.aspectj.weaver.patterns.AndTypePattern) weaverNode;
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.AndTypePattern(
						this.ast, convert(compilerAndType.getLeft()),
						convert(compilerAndType.getRight()));
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.NotTypePattern) {
				//NOTE: the source range for not type patterns is the source range of the negated type pattern
				// EXCLUDING the "!" character. Example: !A. If A starts at 1, the source starting point for the
				// nottypepattern is 1, NOT 0.
				TypePattern negatedTypePattern = ((org.aspectj.weaver.patterns.NotTypePattern) weaverNode)
						.getNegatedPattern();
				org.aspectj.org.eclipse.jdt.core.dom.TypePattern negatedDomTypePattern = convert(negatedTypePattern);
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern(
						ast, negatedDomTypePattern);
			} else if (weaverNode instanceof org.aspectj.weaver.patterns.TypeCategoryTypePattern) {
				org.aspectj.weaver.patterns.TypeCategoryTypePattern typeCategoryWeaverNode = (org.aspectj.weaver.patterns.TypeCategoryTypePattern) weaverNode;
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern(
						ast, typeCategoryWeaverNode.getTypeCategory());

			} else if (weaverNode instanceof org.aspectj.weaver.patterns.HasMemberTypePattern) {
				ISignaturePattern weaverSignature = ((org.aspectj.weaver.patterns.HasMemberTypePattern) weaverNode)
						.getSignaturePattern();
				org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern signature = convertSignature(weaverSignature);
				domNode = new org.aspectj.org.eclipse.jdt.core.dom.HasMemberTypePattern(
						ast, signature);
			} else {
				// Handle any cases that are not yet implemented. Create a
				// default node for
				// them.
				domNode = new DefaultTypePattern(this.ast,
						weaverNode.toString());
			}
		}

		if (domNode != null) {
			domNode.setSourceRange(weaverNode.getStart(), (weaverNode.getEnd()
					- weaverNode.getStart() + 1));
		}
		return domNode;
	}

	/**
	 * Creates an ExactType, WildType, or BindingType, or null if none of the
	 * three can be created
	 * 
	 * @param weaverTypePattern
	 *            to convert to a DOM equivalent
	 * @return DOM node or null if it was not created
	 */
	protected org.aspectj.org.eclipse.jdt.core.dom.TypePattern createIdentifierTypePattern(
			TypePattern weaverTypePattern) {
		String typeExpression = weaverTypePattern.toString();

		org.aspectj.org.eclipse.jdt.core.dom.TypePattern domTypePattern = null;
		if (weaverTypePattern instanceof org.aspectj.weaver.patterns.WildTypePattern) {
			// Use the expression for wild type patterns as a Name may not be
			// constructed
			// for a Type with a unresolved typeExpression
			domTypePattern = new org.aspectj.org.eclipse.jdt.core.dom.WildTypePattern(
					ast, typeExpression);
		} else {
			// TODO: At this point, the type pattern should be resolved. Type
			// information
			// may be able to be obtained from the exact type in the weaver
			// pattern, therefore
			// replace using the expression to construct the Type and use more
			// appropriate
			// information obtained from the exact type

			if (weaverTypePattern instanceof org.aspectj.weaver.patterns.ExactTypePattern) {
				Type type = this.ast.newSimpleType(this.ast
						.newSimpleName(typeExpression));
				domTypePattern = new ExactTypePattern(ast, type);
			} else if (weaverTypePattern instanceof org.aspectj.weaver.patterns.BindingTypePattern) {
				Type type = this.ast.newSimpleType(this.ast
						.newSimpleName(typeExpression));
				String binding = ((org.aspectj.weaver.patterns.BindingTypePattern) weaverTypePattern)
						.getBindingName();
				FormalBinding formalBinding = new FormalBinding(type, binding,
						ast);
				domTypePattern = new org.aspectj.org.eclipse.jdt.core.dom.BindingTypePattern(
						ast, formalBinding);
			}
		}
		return domTypePattern;
	}

	public ASTNode convert(
			org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration annotationTypeMemberDeclaration) {
		checkCanceled();




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * 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

		}
		return node.getDetail().equals(((SignaturePattern) other).getDetail());
	}

	public boolean match(AndTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof AndTypePattern)) {
			return false;
		}
		AndTypePattern otherBoolean = (AndTypePattern) other;
		return safeSubtreeMatch(node.getLeft(), otherBoolean.getLeft())
				&& safeSubtreeMatch(node.getRight(), otherBoolean.getRight());
	}

	public boolean match(OrTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof OrTypePattern)) {
			return false;
		}
		OrTypePattern otherBoolean = (OrTypePattern) other;
		return safeSubtreeMatch(node.getLeft(), otherBoolean.getLeft())
				&& safeSubtreeMatch(node.getRight(), otherBoolean.getRight());
	}

	public boolean match(AnyTypePattern node, Object other) {
		// AnyTypePattern nodes don't hold state aside from the AST, so just do a reference check
		if (node == other) {
			return true;
		}
		return false;
	}

	public boolean match(AnyWithAnnotationTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof AnyWithAnnotationTypePattern)) {
			return false;
		}
		// For now only do an expression matching. In future versions, when
		// the node supports AnnotationTypes, this may have to be changed
		return node.getTypePatternExpression().equals(
				((AnyWithAnnotationTypePattern) other)
						.getTypePatternExpression());
	}

	public boolean match(EllipsisTypePattern node, Object other) {
		// Ellipsis nodes don't hold state aside from the AST, so just do a reference check
		if (node == other) {
			return true;
		}
		return false;
	}

	public boolean match(NotTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof NotTypePattern)) {
			return false;
		}
		return safeSubtreeMatch(node.getNegatedTypePattern(),
				((NotTypePattern) other).getNegatedTypePattern());
	}

	public boolean match(NoTypePattern node, Object other) {
		// NoTypePattern nodes don't hold state aside from the AST, so just do a reference check
		if (node == other) {
			return true;
		}
		return false;
	}

	public boolean match(HasMemberTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof HasMemberTypePattern)) {
			return false;
		}
		return safeSubtreeMatch(node.getSignaturePattern(),
				((HasMemberTypePattern) other).getSignaturePattern());
	}

	public boolean match(IdentifierTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof IdentifierTypePattern)) {
			return false;
		}
		return safeSubtreeMatch(node.getType(),
				((IdentifierTypePattern) other).getType());
	}

	public boolean match(TypeCategoryTypePattern node, Object other) {
		if (node == other) {
			return true;
		}
		if (!(other instanceof TypeCategoryTypePattern)) {
			return false;
		}
		return node.getTypeCategory() == ((TypeCategoryTypePattern) other)
				.getTypeCategory();
	}

	public boolean match(Type type, Object other) {
		if (type == other) {
			return true;
		}
		// For now only support simple type/simple name matching. Support for
		// other types
		// may have to be added here
		if (type instanceof SimpleType && other instanceof SimpleType) {
			Name name = ((SimpleType) type).getName();
			Name otherName = ((SimpleType) other).getName();
			if (name instanceof SimpleName && otherName instanceof SimpleName) {
				return ((SimpleName) name).getIdentifier().equals(
						((SimpleName) otherName).getIdentifier());
			}
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * 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

	
	public void endVisit(SignaturePattern node) {
	}
	
	/*
	 * TODO: if necessary split this into the two specialised
	 * boolean type patterns (AndTypePattern, OrTypePattern)
	 */
	public boolean visit(AbstractBooleanTypePattern node) {
		return true;
	}

	public void endVisit(AbstractBooleanTypePattern node) {

	}

	public boolean visit(AnyTypePattern node) {
		return true;
	}

	public void endVisit(AnyTypePattern node) {

	}

	public boolean visit(AnyWithAnnotationTypePattern node) {
		return true;
	}

	public void endVisit(AnyWithAnnotationTypePattern node) {

	}

	public boolean visit(EllipsisTypePattern node) {
		return true;
	}

	public void endVisit(EllipsisTypePattern node) {

	}

	public boolean visit(HasMemberTypePattern node) {
		return true;
	}

	public void endVisit(HasMemberTypePattern node) {

	}

	public boolean visit(IdentifierTypePattern node) {
		return true;
	}

	public void endVisit(IdentifierTypePattern node) {

	}

	public boolean visit(NotTypePattern node) {
		return true;
	}

	public void endVisit(NotTypePattern node) {

	}

	public boolean visit(NoTypePattern node) {
		return true;
	}

	public void endVisit(NoTypePattern node) {

	}

	public boolean visit(TypeCategoryTypePattern node) {
		return true;
	}

	public void endVisit(TypeCategoryTypePattern node) {

	}
	
	public boolean visit(Type node) {
		return true;
	}

	public void endVisit(Type node) {
	
	}
}

Lines 1-5 Link Here

(-)src/org/aspectj/org/eclipse/jdt/core/dom/AjNaiveASTFlattener.java (-4 / +56 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1720-1730 Link Here
1720	return false;	1720	return false;
1721	}	1721	}
1722		1722
1723	public boolean visit(DefaultTypePattern node) {	1723	public boolean visit(AbstractBooleanTypePattern node) {
1724	this.buffer.append(node.getDetail());	1724
		1725	// Flatten boolean expressions in order, meaning
		1726	// the left node needs to be appended first, followed by the
		1727	// boolean operator, followed by the right node.
		1728	node.getLeft().accept(this);
		1729	this.buffer.append(" ");
		1730	this.buffer.append(node.getTypePatternExpression());
		1731	this.buffer.append(" ");
		1732	node.getRight().accept(this);
		1733
		1734	// No need to visit the childrena, as they were already visited above
1725	return false;	1735	return false;
1726	}	1736	}
1727		1737
		1738	public boolean visit(AnyTypePattern node) {
		1739	this.buffer.append(node.getTypePatternExpression());
		1740	return false;
		1741	}
		1742
		1743	public boolean visit(AnyWithAnnotationTypePattern node) {
		1744	this.buffer.append(node.getTypePatternExpression());
		1745	return false;
		1746	}
		1747
		1748	public boolean visit(EllipsisTypePattern node) {
		1749	this.buffer.append(node.getTypePatternExpression());
		1750	return false;
		1751	}
		1752
		1753	public boolean visit(HasMemberTypePattern node) {
		1754	this.buffer.append(node.getTypePatternExpression());
		1755	return false;
		1756	}
		1757
		1758	public boolean visit(IdentifierTypePattern node) {
		1759	this.buffer.append(node.getTypePatternExpression());
		1760	return false;
		1761	}
		1762
		1763	public boolean visit(NotTypePattern node) {
		1764	this.buffer.append(node.getTypePatternExpression());
		1765	// Visit the children in this case, as the child of a not type pattern
		1766	// is the negated type pattern
		1767	return true;
		1768	}
		1769
		1770	public boolean visit(NoTypePattern node) {
		1771	this.buffer.append(node.getTypePatternExpression());
		1772	return false;
		1773	}
		1774
		1775	public boolean visit(TypeCategoryTypePattern node) {
		1776	this.buffer.append(node.getTypePatternExpression());
		1777	return false;
		1778	}
		1779
1728	public boolean visit(DefaultPointcut node) {	1780	public boolean visit(DefaultPointcut node) {
1729	this.buffer.append(node.getDetail());	1781	this.buffer.append(node.getDetail());
1730	return false;	1782	return false;




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class AndTypePattern extends AbstractBooleanTypePattern {

	public static final String AND_OPERATOR = "&&";

	AndTypePattern(AST ast, TypePattern left, TypePattern right) {
		super(ast, left, right, AND_OPERATOR);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		AndTypePattern cloned = new AndTypePattern(target,
				(TypePattern) getLeft().clone(target), (TypePattern) getRight()
						.clone(target));
		cloned.setSourceRange(getStartPosition(), getLength());
		return cloned;
	}
	
	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visit = ajVisitor.visit(this);
			if (visit) {
				acceptChild(visitor, getLeft());
				acceptChild(visitor, getRight());
			}
			ajVisitor.endVisit(this);
		}
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class AnyTypePattern extends TypePattern {

	public static final String ANYTYPE_DETAIL = "*";

	AnyTypePattern(AST ast) {
		super(ast, ANYTYPE_DETAIL);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		AnyTypePattern cloned = new AnyTypePattern(target);
		cloned.setSourceRange(getStartPosition(), getLength());
		return cloned;
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}
	
	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			ajVisitor.visit(this);
			ajVisitor.endVisit(this);
		}
	}
}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

/**
 * TODO: Add support for proper AnnotationPatterns instead of the annotation
 * expression
 * 
 */
public class AnyWithAnnotationTypePattern extends TypePattern {

	AnyWithAnnotationTypePattern(AST ast, String annotationExpression) {
		// Is this correct? should the "*" be added
		super(ast, annotationExpression);
	}

	ASTNode clone0(AST target) {
		ASTNode node = new AnyWithAnnotationTypePattern(target,
				getTypePatternExpression());
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}
	
	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			ajVisitor.visit(this);
			ajVisitor.endVisit(this);
		}
	}
}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class BindingTypePattern extends IdentifierTypePattern {

	private FormalBinding formalBinding;

	public BindingTypePattern(AST ast, FormalBinding formalBinding) {
		super(ast, null);
		this.formalBinding = formalBinding;
		setTypePatternExpression(generateTypePatternExpression(this.formalBinding));
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	public FormalBinding getFormalBinding() {
		return formalBinding;
	}

	ASTNode clone0(AST target) {
		ASTNode node = new BindingTypePattern(target,
				(FormalBinding) getFormalBinding().clone(target));
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}

	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visited = ajVisitor.visit(this);

			if (visited) {
				ajVisitor.visit(getFormalBinding());
			}
			ajVisitor.endVisit(this);
		}
	}

	protected String generateTypePatternExpression(FormalBinding formalBinding) {
		String expression = super.generateTypePatternExpression(formalBinding
				.getType());
		expression += expression + " " + formalBinding.getBinding();
		return expression;
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class EllipsisTypePattern extends TypePattern {

	public static final String ELLIPSIS_DETAIL = "..";

	EllipsisTypePattern(AST ast) {
		super(ast, ELLIPSIS_DETAIL);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		ASTNode node = new EllipsisTypePattern(target);
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			ajVisitor.visit(this);
			ajVisitor.endVisit(this);
		}
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class ExactTypePattern extends IdentifierTypePattern {

	ExactTypePattern(AST ast, Type type) {
		super(ast, type);
	}


	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		Type clonedType = getType();
		if (clonedType != null) {
			clonedType = (Type) clonedType.clone(target);
		}
		ASTNode node = new ExactTypePattern(target, clonedType);
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class FormalBinding extends Type {

	private Type type;
	private String binding;

	/**
	 * 
	 * @param type
	 *            must not be null
	 * @param binding
	 *            must not be null
	 * @param ast
	 *            must not be null
	 */
	public FormalBinding(Type type, String binding, AST ast) {
		super(ast);
	}

	public Type getType() {
		return type;
	}

	public String getBinding() {
		return binding;
	}

	@Override
	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	@Override
	int getNodeType0() {
		return 0;
	}

	@Override
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			return ((AjASTMatcher) matcher).match(this, other);
		}
		return false;
	}

	@Override
	ASTNode clone0(AST target) {
		ASTNode node = new FormalBinding((Type) getType().clone(target),
				getBinding(), target);
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}

	@Override
	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			boolean visited = ((AjASTVisitor) visitor).visit(this);
			if (visited) {
				((AjASTVisitor) visitor).visit(getType());
			}
			((AjASTVisitor) visitor).endVisit(this);
		}

	}

	@Override
	int treeSize() {
		return getType().treeSize();
	}

	@Override
	int memSize() {
		return BASE_NODE_SIZE + (3 * 4) + getType().memSize();
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

/**
 *
 */
public class HasMemberTypePattern extends TypePattern {

	private SignaturePattern signaturePattern;

	public HasMemberTypePattern(AST ast, SignaturePattern signaturePattern) {
		super(ast, signaturePattern.getDetail());
		this.signaturePattern = signaturePattern;
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	public SignaturePattern getSignaturePattern() {
		return signaturePattern;
	}

	ASTNode clone0(AST target) {
		ASTNode cloned = new HasMemberTypePattern(target,
				(SignaturePattern) getSignaturePattern().clone(target));
		cloned.setSourceRange(getStartPosition(), getLength());
		return cloned;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visited = ajVisitor.visit(this);
			if (visited) {
				ajVisitor.visit(getSignaturePattern());
			}
			ajVisitor.endVisit(this);
		}
	}

	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

	int memSize() {
		return super.memSize() + getSignaturePattern().memSize();
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

public abstract class IdentifierTypePattern extends TypePattern {

	private Type type;

	IdentifierTypePattern(AST ast, Type type) {
		super(ast);
		this.type = type;
		setTypePatternExpression(generateTypePatternExpression(this.type));
	}

	/**
	 * This may be null if no Type has been resolved. A String representation
	 * may still exist.
	 * 
	 * @return type if defined or resolved, or null if not defined or resolved
	 *         at the time when this node is created
	 */
	public Type getType() {
		return type;
	}

	/**
	 * Generate an expression (String representation) for the given type.
	 * 
	 * @param type
	 * @return non-null expression for the given type. Null if no expression can
	 *         be generated.
	 */
	protected String generateTypePatternExpression(Type type) {
		String typeExpression = null;
		if (type instanceof SimpleType) {
			Name name = ((SimpleType) type).getName();
			if (name instanceof SimpleName) {
				typeExpression = ((SimpleName) name).getIdentifier();
			}
		}

		// If expression hasn't been resolved yet, get the toString
		// representation
		if (typeExpression == null && type != null) {
			typeExpression = type.toString();
		}

		return typeExpression;
	}

	int memSize() {

		int memSize = super.memSize();

		Type type = getType();
		if (type != null) {
			memSize += type.memSize();
		}

		return memSize;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visited = ajVisitor.visit(this);
			Type type = getType();
			if (visited && type != null) {
				ajVisitor.visit(type);
			}
			ajVisitor.endVisit(this);
		}
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class NoTypePattern extends TypePattern {

	NoTypePattern(AST ast) {
		super(ast);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	public boolean isStar() {
		return false;
	}

	ASTNode clone0(AST target) {
		ASTNode node = new NoTypePattern(target);
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}
	
	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			ajVisitor.visit(this);
			ajVisitor.endVisit(this);
		}
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class NotTypePattern extends TypePattern {

	private TypePattern negatedPattern;

	/**
	 * The negated type pattern cannot be null
	 * 
	 * @param ast
	 *            not null
	 * @param negatedPattern
	 *            not null
	 */
	NotTypePattern(AST ast, TypePattern negatedPattern) {
		super(ast, "!");
		this.negatedPattern = negatedPattern;
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	public TypePattern getNegatedTypePattern() {
		return negatedPattern;
	}

	ASTNode clone0(AST target) {
		ASTNode node = new NotTypePattern(target,
				(TypePattern) getNegatedTypePattern().clone(target));
		node.setSourceRange(getStartPosition(), getLength());
		return node;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visit = ajVisitor.visit(this);
			if (visit) {
				acceptChild(ajVisitor, getNegatedTypePattern());
			}
			ajVisitor.endVisit(this);
		}
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

	int memSize() {
		return super.memSize() + getNegatedTypePattern().memSize();
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class OrTypePattern extends AbstractBooleanTypePattern {

	public static final String OR_OPERATOR = "||";

	OrTypePattern(AST ast,
			org.aspectj.org.eclipse.jdt.core.dom.TypePattern left,
			org.aspectj.org.eclipse.jdt.core.dom.TypePattern right) {
		super(ast, left, right, OR_OPERATOR);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		OrTypePattern cloned = new OrTypePattern(target,
				(TypePattern) getLeft().clone(target), (TypePattern) getRight()
						.clone(target));
		cloned.setSourceRange(getStartPosition(), getLength());
		return cloned;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			boolean visit = ajVisitor.visit(this);
			if (visit) {
				acceptChild(visitor, getLeft());
				acceptChild(visitor, getRight());
			}
			ajVisitor.endVisit(this);
		}
	}

	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}
}

Lines 1-5 Link Here

(-)src/org/aspectj/org/eclipse/jdt/core/dom/PatternNode.java (-2 / +2 lines)
1	/********************************************************************	1	/********************************************************************
2	* Copyright (c) 2006 Contributors. All rights reserved.	2	* Copyright (c) 2006, 2010 Contributors. All rights reserved.
3	* This program and the accompanying materials are made available	3	* This program and the accompanying materials are made available
4	* under the terms of the Eclipse Public License v1.0	4	* under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution and is available at	5	* which accompanies this distribution and is available at
Lines 27-31 Link Here
27	int memSize() {	27	int memSize() {
28	return 0; // stub method	28	return 0; // stub method
29	}	29	}
30		30
31	}	31	}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class TypeCategoryTypePattern extends TypePattern {

	private int typeCategory;

	public static final int CLASS = org.aspectj.weaver.patterns.TypeCategoryTypePattern.CLASS;
	public static final int INTERFACE = org.aspectj.weaver.patterns.TypeCategoryTypePattern.INTERFACE;
	public static final int ASPECT = org.aspectj.weaver.patterns.TypeCategoryTypePattern.ASPECT;
	public static final int INNER = org.aspectj.weaver.patterns.TypeCategoryTypePattern.INNER;
	public static final int ANONYMOUS = org.aspectj.weaver.patterns.TypeCategoryTypePattern.ANONYMOUS;
	public static final int ENUM = org.aspectj.weaver.patterns.TypeCategoryTypePattern.ENUM;
	public static final int ANNOTATION = org.aspectj.weaver.patterns.TypeCategoryTypePattern.ANNOTATION;

	/**
	 * 
	 * See the weaver implementation for the type categories.
	 * 
	 * @see org.aspectj.weaver.patterns.TypeCategoryTypePattern
	 * @param ast
	 *            must not be null
	 * @param typeCategory
	 *            as defined in the corresponding weaver node type
	 */
	TypeCategoryTypePattern(AST ast, int typeCategory) {
		super(ast, null);
		this.typeCategory = typeCategory;
	}

	/**
	 * 
	 * See the weaver implementation for the type categories.
	 * 
	 * @see org.aspectj.weaver.patterns.TypeCategoryTypePattern
	 * @return type category
	 */
	public int getTypeCategory() {
		return typeCategory;
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	public String getTypePatternExpression() {

		String expression = super.getTypePatternExpression();
		if (expression == null) {
			switch (getTypeCategory()) {
			case CLASS:
				expression = "ClassType";
				break;
			case INNER:
				expression = "InnerType";
				break;
			case INTERFACE:
				expression = "InterfaceType";
				break;
			case ANNOTATION:
				expression = "AnnotationType";
				break;
			case ANONYMOUS:
				expression = "AnonymousType";
				break;
			case ASPECT:
				expression = "AspectType";
				break;
			case ENUM:
				expression = "EnumType";
				break;
			}
			expression = (expression != null) ? "is(" + expression + ")"
					: EMPTY_EXPRESSION;
			setTypePatternExpression(expression);

		}
		return expression;
	}

	ASTNode clone0(AST target) {
		ASTNode cloned = new TypeCategoryTypePattern(target, getTypeCategory());
		cloned.setSourceRange(getStartPosition(), getLength());
		return cloned;
	}

	void accept0(ASTVisitor visitor) {
		if (visitor instanceof AjASTVisitor) {
			AjASTVisitor ajVisitor = (AjASTVisitor) visitor;
			ajVisitor.visit(this);
			ajVisitor.endVisit(this);
		}
	}

	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

}




/********************************************************************
 * Copyright (c) 2006, 2010 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 

 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;


/**
 * abstract TypePattern DOM AST node.
 * has:
 *   nothing at the moment
 */
public abstract class TypePattern extends PatternNode {

	private String typePatternExpression;
	
	public static final String EMPTY_EXPRESSION = "";

	TypePattern(AST ast) {
		super(ast);
	}

	TypePattern(AST ast, String typePatternExpression) {
		super(ast);
		this.typePatternExpression = typePatternExpression;
	}

	/**
	 * Should be called for internal setting only, if the expression needs to be set
	 * lazily
	 * @param typePatternExpression
	 */
	protected void setTypePatternExpression(String typePatternExpression) {
		this.typePatternExpression = typePatternExpression;
	}

	/**
	 * Return the type pattern in expression form (String representation). In
	 * many cases, this is not null, although it may be null in some cases like
	 * the NoTypePattern
	 * 
	 * @return String expression of the type pattern. May be null.
	 */
	public String getTypePatternExpression() {
		return typePatternExpression;
	}

	int treeSize() {
		return memSize();
	}

}




/********************************************************************
 * Copyright (c) 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: Nieraj Singh - initial implementation
 *******************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;

import java.util.List;

public class WildTypePattern extends IdentifierTypePattern {

	/**
	 * Use this constructor if Type is known
	 * 
	 * @param ast
	 * @param type
	 */
	WildTypePattern(AST ast, Type type) {
		super(ast, type);
	}

	/**
	 * Use this constructor if Type cannot be determined
	 * 
	 * @param ast
	 * @param typeExpression
	 */
	WildTypePattern(AST ast, String typeExpression) {
		super(ast, null);
		setTypePatternExpression(typeExpression);
	}

	List<?> internalStructuralPropertiesForType(int apiLevel) {
		return null;
	}

	ASTNode clone0(AST target) {
		Type type = getType();

		ASTNode cloned = type != null ? new WildTypePattern(target,
				(Type) type.clone(target)) : new WildTypePattern(target,
				getTypePatternExpression());
		cloned.setSourceRange(getStartPosition(), getLength());

		return cloned;
	}
	
	boolean subtreeMatch0(ASTMatcher matcher, Object other) {
		if (matcher instanceof AjASTMatcher) {
			AjASTMatcher ajmatcher = (AjASTMatcher) matcher;
			return ajmatcher.match(this, other);
		}
		return false;
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * 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


import org.aspectj.org.eclipse.jdt.core.dom.AST;
import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;
import org.aspectj.org.eclipse.jdt.core.dom.AbstractBooleanTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;
import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AndTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.Assignment;
import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.BindingTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.Block;
import org.aspectj.org.eclipse.jdt.core.dom.BlockComment;
import org.aspectj.org.eclipse.jdt.core.dom.BodyDeclaration;

import org.aspectj.org.eclipse.jdt.core.dom.DeclarePrecedenceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.DeclareSoftDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.DefaultTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.EnumDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.ExactTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.ExpressionStatement;
import org.aspectj.org.eclipse.jdt.core.dom.FieldAccess;
import org.aspectj.org.eclipse.jdt.core.dom.FieldDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.IdentifierTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.InfixExpression;
import org.aspectj.org.eclipse.jdt.core.dom.Initializer;
import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.MethodDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.MethodInvocation;
import org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.NumberLiteral;
import org.aspectj.org.eclipse.jdt.core.dom.OrTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;
import org.aspectj.org.eclipse.jdt.core.dom.PerObject;
import org.aspectj.org.eclipse.jdt.core.dom.PerTypeWithin;

import org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern;
import org.aspectj.org.eclipse.jdt.core.dom.SimpleName;
import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;
import org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.aspectj.org.eclipse.jdt.core.dom.WildTypePattern;
import org.aspectj.org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

public class ASTVisitorTest extends TestCase {

				"(compilationUnit(class(simpleName)(method(primitiveType)(simpleName)(block(expressionStatement(methodInvocation(simpleName))))))(aspect(simpleName)(constructorITD(primitiveType)(simpleName)(block))))");
	}
	
	/*
	 * 
	 * START: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 */
	
	public void testDeclareParents() {
		check("class A{}class B{}aspect C {declare parents : A extends B;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents(wildTypePattern)(wildTypePattern))))");
	}

	public void testDeclareParentsAnyTypePattern() {
		check("class A{}class B{}aspect C {declare parents : * extends B;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents(anyTypePattern)(wildTypePattern))))");
	}

	public void testDeclareParentsAndTypePattern() {
		check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && B && D extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern((wildTypePattern)andTypePattern(wildTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsOrTypePattern() {
		check("class A{}class B{}class D{}class E{}aspect C {declare parents : A || B || D extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)orTypePattern((wildTypePattern)orTypePattern(wildTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsAndOrTypePattern() {
		check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && (B || D) extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern((wildTypePattern)orTypePattern(wildTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsOrAndTypePattern() {
		check("class A{}class B{}class D{}class E{}aspect C {declare parents : A || B && D extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)orTypePattern((wildTypePattern)andTypePattern(wildTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsNotTypePattern() {
		check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && !B extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(notTypePattern(wildTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsTypeCategoryTypePattern() {
		check("class A{}class E{}aspect C {declare parents : A && is(ClassType) extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(typeCategoryTypePattern))(wildTypePattern))))");
	}

	public void testDeclareParentsTypeCategoryTypePatternNot() {
		check("class A{}class E{}aspect C {declare parents : A && !is(InnerType) extends E;}",
				"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(notTypePattern(typeCategoryTypePattern)))(wildTypePattern))))");
	}

	public void testDeclareParentsAnyWithAnnotationTypePattern() {
		check("class E{}aspect C {declare parents : (@AnnotationT *) extends E;}",
				"(compilationUnit(class(simpleName))(aspect(simpleName)(declareParents(anyWithAnnotationTypePattern)(wildTypePattern))))");
	}
	
	
	/*
	 * 
	 * END: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 */
	
	
	public void testDeclareWarning(){
		check("aspect A {pointcut a();declare warning: a(): \"warning\";}",
				"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareWarning(referencePointcut(simpleName))(stringLiteral))))");

	}
	public void testDeclareSoft(){
		check("aspect A {pointcut a();declare soft: Exception+: a();}",
				"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareSoft(referencePointcut(simpleName))(wildTypePattern))))");
	}
	public void testDeclarePrecedence(){
		check("aspect A{}aspect B{declare precedence: B,A;}",
				"(compilationUnit(aspect(simpleName))(aspect(simpleName)(declarePrecedence(wildTypePattern)(wildTypePattern))))");
	}
	public void testDeclareAnnotationType(){
		checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @type: C : @MyAnnotation;}",
				"(compilationUnit(simpleName)(class(simpleName))(aspect(simpleName)(declareAtType(wildTypePattern)(simpleName))))");
	}
	public void testDeclareAnnotationMethod(){
		checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @method:public * C.*(..) : @MyAnnotation;}",

	public void endVisit(DeclareWarningDeclaration node) {
		b.append(")"); //$NON-NLS-1$
	}
	
	public boolean visit(AbstractBooleanTypePattern node) {
		b.append("(");
		node.getLeft().accept(this);
		if (node instanceof AndTypePattern) {
			b.append("andTypePattern");
		} else if (node instanceof OrTypePattern) {
			b.append("orTypePattern");
		}
		node.getRight().accept(this);
		b.append(")");
		
		// Don't visit the children, as that is done above in order (left node first, boolean operator next, right node last
		return false;
	}


	public boolean visit(AnyTypePattern node) {
		b.append("(anyTypePattern");
		return isVisitingChildren();
	}


	public void endVisit(AnyTypePattern node) {
		b.append(")"); 
	}


	public boolean visit(AnyWithAnnotationTypePattern node) {
		b.append("(anyWithAnnotationTypePattern");
		return isVisitingChildren();
	}


	public void endVisit(AnyWithAnnotationTypePattern node) {
		b.append(")"); 
	}

	public boolean visit(IdentifierTypePattern node) {
		if (node instanceof WildTypePattern) {
			b.append("(wildTypePattern");
		} else if (node instanceof ExactTypePattern) {
			b.append("(exactTypePattern");
		} else if (node instanceof BindingTypePattern) {
			b.append("(bindingTypePattern");
		}
		return isVisitingChildren();
	}


	public void endVisit(IdentifierTypePattern node) {
		b.append(")"); 
	}


	public boolean visit(NotTypePattern node) {
		b.append("(notTypePattern");
		return isVisitingChildren();
	}


	public void endVisit(NotTypePattern node) {
		b.append(")"); 
	}


	public boolean visit(TypeCategoryTypePattern node) {
		b.append("(typeCategoryTypePattern");
		return isVisitingChildren();
	}


	public void endVisit(TypeCategoryTypePattern node) {
		b.append(")"); 
	}
	
	
	// End of TypePattern additions for Bugzilla 329268

	public boolean visit(SignaturePattern node) {
		b.append("(signaturePattern");
		return isVisitingChildren();		




/********************************************************************
 * Copyright (c) 2006, 2010 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: IBM Corporation - initial API and implementation 
 * 				 Helen Hawkins   - initial version
 *******************************************************************/
package org.aspectj.tools.ajc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.aspectj.org.eclipse.jdt.core.dom.AST;
import org.aspectj.org.eclipse.jdt.core.dom.ASTNode;
import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;
import org.aspectj.org.eclipse.jdt.core.dom.AbstractBooleanTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;

import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;
import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AndPointcut;
import org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;

import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.DefaultPointcut;
import org.aspectj.org.eclipse.jdt.core.dom.DefaultTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.EllipsisTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.HasMemberTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.IExtendedModifier;
import org.aspectj.org.eclipse.jdt.core.dom.IdentifierTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.Javadoc;
import org.aspectj.org.eclipse.jdt.core.dom.NoTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.NotPointcut;
import org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.OrPointcut;
import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;
import org.aspectj.org.eclipse.jdt.core.dom.PerObject;

import org.aspectj.org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;
import org.aspectj.org.eclipse.jdt.core.dom.Type;
import org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern;
import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;
import org.aspectj.org.eclipse.jdt.core.dom.TypePattern;
import org.aspectj.org.eclipse.jdt.internal.core.SourceRange;

/**
 * For each AspectJ ASTNode there is a test for:

	public void testDeclareParents() {
		checkJLS3("class A{}class B{}aspect C {declare parents : A extends B;}", 28, 29);
	}
	
	
	/*
	 * 
	 * 
	 * START: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 * 
	 */
	
	public void testDeclareParentsTypePatternNodeSource() {
		checkTypePatternSourceRangesJLS3("class A{}class B{}aspect C {declare parents : A extends B;}", new int[][] {{46, 1} , {56, 1 }});
	}
	
	public void testDeclareParentsAnySource() {
		checkTypePatternSourceRangesJLS3("class A{}class B{}aspect C {declare parents : * extends B;}", new int[][] {{46, 1} , {56, 1 }});
	}
	
	public void testDeclareParentsAndSource() {

		checkTypePatternSourceRangesJLS3(
				"class A{}class B{}class D{}class E{}aspect C {declare parents : A && B && D extends E;}",
				new int[][] { { 64, 11 },// A && B && D,
						{ 64, 1 }, // A
						{ 69, 6 }, // B && D
						{ 69, 1 }, // B
						{ 74, 1 }, // D
						{ 84, 1 } // E
				});
	}
	
	public void testDeclareParentsNotSource() {

		checkTypePatternSourceRangesJLS3(
				"class A{}class B{}class D{}class E{}aspect C {declare parents : A && !B extends E;}",
				new int[][] { { 64, 7 },// A && !B
						{ 64, 1 }, // A
						{ 70, 1 }, // !B: the source location for a negated pattern is the start of the negated pattern excluding "!". Is this a bug?
						{ 70, 1 }, // B
						{ 80, 1 } // E
				});
	}
	
	public void testDeclareParentsOrSource() {
		checkTypePatternSourceRangesJLS3(
				"class A{}class B{}class D{}class E{}aspect C {declare parents : A || B || D extends E;}",
				new int[][] { { 64, 11 },// A || B || D,
						{ 64, 1 }, // A
						{ 69, 6 }, // B || D
						{ 69, 1 }, // B
						{ 74, 1 }, // D
						{ 84, 1 } // E
				});
	}
	
	public void testDeclareParentsAnyWithAnnotationSource() {
		checkTypePatternSourceRangesJLS3(
				"@interface AnnotationT {}class E{}aspect C {declare parents : (@AnnotationT *) extends E;}",
				new int[][] { { 62, 16 },// (@AnnotationT *)
						{ 87, 1 } // E
				});
		
	}
	
	public void testDeclareParentsTypeCategorySource() {
		checkTypePatternSourceRangesJLS3(
				"class A{}class E{}aspect C {declare parents : A && is(ClassType) extends E;}",
				new int[][] { { 46, 18 },// A && !is(InnerType)
						{ 46, 1 }, // A
						{ 51, 13}, // is(InnerType)
						{ 73, 1 } // E
				});
	}

	public void testDeclareParentsTypeCategoryNotSource() {
		checkTypePatternSourceRangesJLS3(
				"class A{}class E{}aspect C {declare parents : A && !is(InnerType) extends E;}",
				new int[][] { { 46, 19 },// A && !is(InnerType)
						{ 46, 1 }, // A
						{ 52, 13}, // !is(InnerType): the source location for a negated pattern is the start of the negated pattern excluding "!". Is this a bug?
						{ 52, 13}, // is(InnerType)
						{ 74, 1 } // E
				});
	}

	// // TODO: commenting out as there isn't proper support for hasmethod(..)
	// yet. Uncomment and fix when hasmethod is supported
	// public void testDeclareParentsHasMember() {
	// // This is wrong. Call checkTypePatternJLS3 instead to check the source
	// ranges for hasMethod...
	// checkJLS3("class A{}class B{ public void fooB() {}}class D{}aspect C {declare parents : A && hasmethod(void foo*(..)) extends D;}",
	// 37, 34);
	// }

	public void testDeclareParentsTypeCategoryInner() {
		checkCategoryTypePatternJLS3(
				"class A{class B{}}class E{}aspect C {declare parents : B && is(InnerType) extends E;}",
				TypeCategoryTypePattern.INNER, "is(InnerType)");
	}

	public void testDeclareParentsTypeCategoryInterface() {
		checkCategoryTypePatternJLS3(
				"interface B{}interface E{}aspect C {declare parents : B && is(InterfaceType) extends E;}",
				TypeCategoryTypePattern.INTERFACE, "is(InterfaceType)");
	}

	public void testDeclareParentsTypeCategoryClass() {
		checkCategoryTypePatternJLS3(
				"class B{}class E{}aspect C {declare parents : B && is(ClassType) extends E;}",
				TypeCategoryTypePattern.CLASS, "is(ClassType)");
	}

	public void testDeclareParentsTypeCategoryAnnotation() {
		checkCategoryTypePatternJLS3(
				"@interface B{}class E{}aspect C {declare parents : B && is(AnnotationType) extends E;}",
				TypeCategoryTypePattern.ANNOTATION, "is(AnnotationType)");
	}

	public void testDeclareParentsTypeCategoryAnonymous() {
		checkCategoryTypePatternJLS3(
				"class A{B annonymousB = new B() {};}class B{}class E{}aspect C {declare parents : B && is(AnonymousType) extends E;}",
				TypeCategoryTypePattern.ANONYMOUS, "is(AnonymousType)");
	}

	public void testDeclareParentsTypeCategoryEnum() {
		checkCategoryTypePatternJLS3(
				"class B{}class E{}aspect C {declare parents : B && !is(EnumType) extends E;}",
				TypeCategoryTypePattern.ENUM, "is(EnumType)");
	}
	
	/*
	 * 
	 * 
	 * END: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 * 
	 */
	
	
	public void testDeclareWarning() {
		checkJLS3("aspect A {pointcut a();declare warning: a(): \"error\";}", 23, 30);
	}

		assertEquals("expected there to be one comment but found " + cu.getCommentList().size(), 1, cu.getCommentList().size());
	}

	
	protected void assertExpression(String expectedExpression, TypePattern node) {
		assertTrue("Expected: " + expectedExpression + ". Actual: " + node.getTypePatternExpression(), node.getTypePatternExpression().equals(expectedExpression));
		
	}
	
	protected void assertNodeType(Class<?> expected, TypePattern node) {
		assertTrue("Expected " + expected.toString() + ". Actual: " + node.getClass().toString(), node.getClass().equals(expected));
	}
}



class TypeCategoryTypeVisitor extends AjASTVisitor {
	
	private TypeCategoryTypePattern typeCategory = null;
	
	public boolean visit(TypeCategoryTypePattern node) {
		typeCategory = node;
		return false;
	}
	
	public TypeCategoryTypePattern getTypeCategoryNode() {
		return typeCategory;
	}
}

class TypePatternSourceRangeVisitor extends AjASTVisitor {
	private List<SourceRange> sourceRanges = new ArrayList<SourceRange>();

	public List<SourceRange> getVisitedSourceRanges() {
		return sourceRanges;
	}

	public boolean visit(AbstractBooleanTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(AnyTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(AnyWithAnnotationTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(EllipsisTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(HasMemberTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(IdentifierTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(NotTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(NoTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}

	public boolean visit(TypeCategoryTypePattern node) {
		sourceRanges.add(new SourceRange(node.getStartPosition(), node
				.getLength()));
		return true;
	}
}


class SourceRangeVisitor extends AjASTVisitor {

	boolean visitTheKids = true;




/********************************************************************
 * Copyright (c) 2006, 2010 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 

 *******************************************************************/
package org.aspectj.tools.ajc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import junit.framework.TestCase;

import org.aspectj.org.eclipse.jdt.core.dom.AST;
import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;
import org.aspectj.org.eclipse.jdt.core.dom.AjAST;
import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;
import org.aspectj.org.eclipse.jdt.core.dom.CompilationUnit;
import org.aspectj.org.eclipse.jdt.internal.core.SourceRange;

public abstract class AjASTTestCase extends TestCase {


		parser.setCompilerOptions(new HashMap());
		CompilationUnit cu = (CompilationUnit) parser.createAST(null);
		AST ast = cu.getAST();
		assertTrue("the ast should be an instance of AjAST",
				ast instanceof AjAST);
		return (AjAST) ast;
	}

	protected void checkJLS3(String source, ITypePatternTester tester) {
		ASTParser parser = ASTParser.newParser(AST.JLS3);
		parser.setCompilerOptions(new HashMap());
		parser.setSource(source.toCharArray());
		CompilationUnit cu2 = (CompilationUnit) parser.createAST(null);
		AjASTVisitor visitor = tester.createVisitor();
		cu2.accept(visitor);
		tester.testCondition(visitor);
	}

	protected void checkJLS3(String source, int start, int length) {
		checkJLS3(source, new SourceRangeTester(start, length));
	}

	/**
	 * 
	 * @param source
	 *            to parse and visit
	 * @param expectedSourceRanges
	 *            of TypePattern nodes encountered while visiting the AST
	 */
	protected void checkTypePatternSourceRangesJLS3(String source,
			int[][] expectedSourceRanges) {
		checkJLS3(source,
				new TypePatternSourceRangeTester(expectedSourceRanges));
	}

	/**
	 * 
	 * @param source
	 *            to parse and visit
	 * @param expectedCategory
	 *            expected category of a TypeCategoryTypePattern node
	 *            encountered in the AST
	 */
	protected void checkCategoryTypePatternJLS3(String source,
			int expectedCategory, String expectedExpression) {
		checkJLS3(source, new TypeCategoryTester(expectedCategory, expectedExpression));
	}


	protected List<SourceRange> getSourceRanges(int[][] sourceRanges) {
		List<SourceRange> convertedRanges = new ArrayList<SourceRange>();

		for (int i = 0; i < sourceRanges.length; i++) {
			convertedRanges.add(new SourceRange(sourceRanges[i][0],
					sourceRanges[i][1]));
		}
		return convertedRanges;
	}

	/*
	 * 
	 * 
	 * Testing Classes and Interfaces
	 */

	/**
	 * Tests the results of a visitor when walking the AST
	 * 
	 */
	interface ITypePatternTester {

		/**
		 * 
		 * @return visitor to walk the AST. Must not be null.
		 */
		public AjASTVisitor createVisitor();

		/**
		 * Tests a condition after the visitor has visited the AST. This means
		 * the visitor should contain the results of the visitation.
		 * 
		 * @return true if test condition passed. False otherwise
		 */
		public void testCondition(AjASTVisitor visitor);
	}

	/**
	 * Tests whether a particular type category type pattern (InnerType,
	 * InterfaceType, ClassType, etc..) is encountered when visiting nodes in an
	 * AST.
	 * 
	 */
	class TypeCategoryTester implements ITypePatternTester {

		private int expectedCategory;
		private String expectedExpression;

		public TypeCategoryTester(int expectedCategory,
				String expectedExpression) {
			this.expectedCategory = expectedCategory;
			this.expectedExpression = expectedExpression;
		}

		public AjASTVisitor createVisitor() {
			return new TypeCategoryTypeVisitor();
		}

		public void testCondition(AjASTVisitor visitor) {
			TypeCategoryTypeVisitor tcVisitor = (TypeCategoryTypeVisitor) visitor;
			assertTrue("Expected type category: " + expectedCategory
					+ ". Actual type category: "
					+ tcVisitor.getTypeCategoryNode().getTypeCategory(),
					expectedCategory == tcVisitor.getTypeCategoryNode()
							.getTypeCategory());
			assertTrue("Expected type category expression: "
					+ expectedExpression
					+ ". Actual type category expression: "
					+ tcVisitor.getTypeCategoryNode()
							.getTypePatternExpression(),
					expectedExpression.equals(tcVisitor.getTypeCategoryNode()
							.getTypePatternExpression()));
		}
	}

	/**
	 * Tests the starting location and source length of each TypePattern node
	 * encountered while walking the AST.
	 * 
	 */
	class TypePatternSourceRangeTester implements ITypePatternTester {

		private int[][] expectedRawSourceRanges;

		public TypePatternSourceRangeTester(int[][] expectedRawSourceRanges) {
			this.expectedRawSourceRanges = expectedRawSourceRanges;
		}

		public AjASTVisitor createVisitor() {
			return new TypePatternSourceRangeVisitor();
		}

		public void testCondition(AjASTVisitor visitor) {
			TypePatternSourceRangeVisitor sourceRangeVisitor = (TypePatternSourceRangeVisitor) visitor;

			List<SourceRange> actualRanges = sourceRangeVisitor
					.getVisitedSourceRanges();
			List<SourceRange> expectedRanges = getSourceRanges(expectedRawSourceRanges);

			assertTrue("Expected " + expectedRanges.size()
					+ " number of source range entries. Actual: "
					+ actualRanges.size(),
					expectedRanges.size() == actualRanges.size());

			for (int i = 0; i < actualRanges.size(); i++) {
				SourceRange expected = expectedRanges.get(i);
				SourceRange actual = actualRanges.get(i);
				assertTrue(
						"Expected source range: " + expected.toString()
								+ " does not match actual source range: "
								+ actual.toString(), expected.equals(actual));
			}

		}
	}

	/**
	 * Tests whether a particular AST node starts at a given expected location
	 * and has an expected length
	 * 
	 */
	class SourceRangeTester implements ITypePatternTester {

		private int expectedStart;
		private int expectedLength;

		public SourceRangeTester(int expectedStart, int expectedLength) {
			this.expectedLength = expectedLength;
			this.expectedStart = expectedStart;
		}

		public AjASTVisitor createVisitor() {
			return new SourceRangeVisitor();
		}

		public void testCondition(AjASTVisitor visitor) {

			int s = ((SourceRangeVisitor) visitor).getStart();
			int l = ((SourceRangeVisitor) visitor).getLength();
			assertTrue("Expected start position: " + expectedStart
					+ ", Actual:" + s, expectedStart == s);
			assertTrue("Expected length: " + expectedLength + ", Actual:" + l,
					expectedLength == l);

		}

	}

}




/********************************************************************
 * Copyright (c) 2006, 2010 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 

				"public aspect A {\n  declare parents: X extends Y;\n}\n");
	}
	
	
	/*
	 * 
	 * 
	 * START: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 * 
	 */
	
	public void testDeclareParentsDeclarationAny() throws Exception {
		check("public aspect A { declare parents: * extends Y; }",
				"public aspect A {\n  declare parents: * extends Y;\n}\n");
	}
	
	public void testDeclareParentsAndDeclaration() throws Exception {
		check("public aspect A { declare parents: W && X && Y extends Z; }",
				"public aspect A {\n  declare parents: W && X && Y extends Z;\n}\n");
	}
	
	public void testDeclareParentsOrDeclaration() throws Exception {
		check("public aspect A { declare parents: W || X || Y extends Z; }",
				"public aspect A {\n  declare parents: W || X || Y extends Z;\n}\n");
	}
	
	public void testDeclareParentsNot() throws Exception {
		check("public aspect A { declare parents: W && !X extends Z; }",
				"public aspect A {\n  declare parents: W && !X extends Z;\n}\n");
	}
	
	public void testDeclareParentsTypeCategory() throws Exception {
		check("public aspect A { declare parents: B && is(AnonymousType) extends Z; }",
		"public aspect A {\n  declare parents: B && is(AnonymousType) extends Z;\n}\n");
		
	}
	
	public void testDeclareParentsTypeCategoryNot() throws Exception {
		check("public aspect A { declare parents: B && !is(InnerType) extends Z; }",
		"public aspect A {\n  declare parents: B && !is(InnerType) extends Z;\n}\n");
	}

	
	// TODO: commented until hasmethod is supported in AspectJ
//	public void testDeclareParentsHasMember() {
//		check("public aspect A { declare parents : A && hasmethod(void foo*(..)) extends D; }",
//		"public aspect A {\n  declare parents : A && hasmethod(void foo*(..)) extends D;\n}\n");
//	}

	
	/*
	 * 
	 * 
	 * END: Test TypePattern nodes introduced in Bugzilla 329268.
	 * 
	 * 
	 */
	
	public void testDeclareWarning() throws Exception {
		check("public aspect A { declare warning: call(* *.*(..)) : \"warning!\"; }",
				"public aspect A {\n  declare warning: call(* *.*(..)) : \"warning!\" ;\n}\n");




/* *******************************************************************
 * Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
 * 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.Map;

import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.World;

public class AnyTypePattern extends TypePattern {

	/**
	 * Constructor for EllipsisTypePattern.
	 * 
	 * @param includeSubtypes
	 */
	public AnyTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return true;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.YES;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(ANY_KEY);
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
	 */
	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }
	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
	 */
	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return true;
	}

	@Override
	public boolean isStar() {
		return true;
	}

	@Override
	public String toString() {
		return "*";
	}

	@Override
	public boolean equals(Object obj) {
		return (obj instanceof AnyTypePattern);
	}

	@Override
	public int hashCode() {
		return 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map arg0, World w) {
		return this;
	}
}




/* *******************************************************************
 * Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
 * 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.lang.reflect.Modifier;
import java.util.Map;

import org.aspectj.bridge.MessageUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.VersionedDataInputStream;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.World;


/**
 * This type represents a type pattern of '*' but with an annotation specified, e.g. '@Color *'
 */
public class AnyWithAnnotationTypePattern extends TypePattern {

	public AnyWithAnnotationTypePattern(AnnotationTypePattern atp) {
		super(false, false);
		annotationPattern = atp;
	}

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

	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type) {
		annotationPattern.resolve(type.getWorld());
		boolean b = false;
		if (type.temporaryAnnotationTypes != null) {
			b = annotationPattern.matches(type, type.temporaryAnnotationTypes).alwaysTrue();
		} else {
			b = annotationPattern.matches(type).alwaysTrue();
		}
		return b;
	}

	@Override
	public TypePattern resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType) {
		if (requireExactType) {
			scope.getWorld().getMessageHandler().handleMessage(
					MessageUtil.error(WeaverMessages.format(WeaverMessages.WILDCARD_NOT_ALLOWED), getSourceLocation()));
			return NO;
		}
		return super.resolveBindings(scope, bindings, allowBinding, requireExactType);
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		annotationPattern.resolve(type.getWorld());
		return annotationPattern.matches(annotatedType).alwaysTrue();
	}

	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		if (Modifier.isFinal(type.getModifiers())) {
			return FuzzyBoolean.fromBoolean(matchesExactly(type));
		}
		return FuzzyBoolean.MAYBE;
	}

	@Override
	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
		AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(this.annotationPattern.parameterizeWith(
				typeVariableMap, w));
		ret.copyLocationFrom(this);
		return ret;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(TypePattern.ANY_WITH_ANNO);
		annotationPattern.write(s);
		writeLocation(s);
	}

	public static TypePattern read(VersionedDataInputStream s, ISourceContext c) throws IOException {
		AnnotationTypePattern annPatt = AnnotationTypePattern.read(s, c);
		AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(annPatt);
		ret.readLocation(c, s);
		return ret;
	}

	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }

	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return true;
	}

	@Override
	public boolean isStar() {
		return false;
	}

	@Override
	public String toString() {
		return "(" + annotationPattern + " *)";
	}
	
	public AnnotationTypePattern getAnnotationTypePattern() {
		return annotationPattern;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof AnyWithAnnotationTypePattern)) {
			return false;
		}
		AnyWithAnnotationTypePattern awatp = (AnyWithAnnotationTypePattern) obj;
		return (annotationPattern.equals(awatp.annotationPattern));
	}

	@Override
	public int hashCode() {
		return annotationPattern.hashCode();
	}
}




/* *******************************************************************
 * Copyright (c) 2002, 2010 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 


public class BindingTypePattern extends ExactTypePattern implements BindingPattern {
	private int formalIndex;
	private String bindingName;

	public BindingTypePattern(UnresolvedType type, int index, boolean isVarArgs) {
		super(type, false, isVarArgs);


	public BindingTypePattern(FormalBinding binding, boolean isVarArgs) {
		this(binding.getType(), binding.getIndex(), isVarArgs);
		this.bindingName = binding.getName();
	}

	public int getFormalIndex() {
		return formalIndex;
	}
	
	public String getBindingName() {
		return bindingName;
	}

	public boolean equals(Object other) {
		if (!(other instanceof BindingTypePattern)) {




/* *******************************************************************
 * Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
 * 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.Map;

import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.World;

public class EllipsisTypePattern extends TypePattern {

	/**
	 * Constructor for EllipsisTypePattern.
	 * 
	 * @param includeSubtypes
	 */
	public EllipsisTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return false;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.NO;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(ELLIPSIS_KEY);
	}

	@Override
	public boolean isEllipsis() {
		return true;
	}

	@Override
	public String toString() {
		return "..";
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		return (obj instanceof EllipsisTypePattern);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		return 17 * 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
		return this;
	}

}

Lines 49-54 Link Here

(-)src/org/aspectj/weaver/patterns/HasMemberTypePattern.java (+4 lines)
49	return hasMethod(type);	49	return hasMethod(type);
50	}	50	}
51	}	51	}
		52
		53	public ISignaturePattern getSignaturePattern() {
		54	return signaturePattern;
		55	}
52		56
53	private final static String declareAtPrefix = "ajc$declare_at";	57	private final static String declareAtPrefix = "ajc$declare_at";
54		58




package org.aspectj.weaver.patterns;

import java.io.IOException;
import java.util.Map;

import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.World;

public class NoTypePattern extends TypePattern {

	public NoTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return false;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.NO;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(NO_KEY);
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
	 */
	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }
	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
	 */
	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return false;
	}

	@Override
	public boolean isStar() {
		return false;
	}

	@Override
	public String toString() {
		return "<nothing>";
	}// FIXME AV - bad! toString() cannot be parsed back (not idempotent)

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		return (obj instanceof NoTypePattern);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		return 17 * 37 * 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map arg0, World w) {
		return this;
	}
}

Lines 44-49 Link Here

(-)src/org/aspectj/weaver/patterns/TypeCategoryTypePattern.java (+4 lines)
44	super(false);	44	super(false);
45	this.category = category;	45	this.category = category;
46	}	46	}
		47
		48	public int getTypeCategory() {
		49	return category;
		50	}
47		51
48	@Override	52	@Override
49	protected boolean matchesExactly(ResolvedType type) {	53	protected boolean matchesExactly(ResolvedType type) {




/* *******************************************************************
 * Copyright (c) 2002, 2010 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 

package org.aspectj.weaver.patterns;

import java.io.IOException;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.Map;

import org.aspectj.bridge.MessageUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.IntMap;
import org.aspectj.weaver.ResolvedType;


}

class EllipsisTypePattern extends TypePattern {

	/**
	 * Constructor for EllipsisTypePattern.
	 * 
	 * @param includeSubtypes
	 */
	public EllipsisTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return false;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.NO;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(ELLIPSIS_KEY);
	}

	@Override
	public boolean isEllipsis() {
		return true;
	}

	@Override
	public String toString() {
		return "..";
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		return (obj instanceof EllipsisTypePattern);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		return 17 * 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
		return this;
	}

}

class AnyTypePattern extends TypePattern {

	/**
	 * Constructor for EllipsisTypePattern.
	 * 
	 * @param includeSubtypes
	 */
	public AnyTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return true;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return true;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.YES;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(ANY_KEY);
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
	 */
	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }
	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
	 */
	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return true;
	}

	@Override
	public boolean isStar() {
		return true;
	}

	@Override
	public String toString() {
		return "*";
	}

	@Override
	public boolean equals(Object obj) {
		return (obj instanceof AnyTypePattern);
	}

	@Override
	public int hashCode() {
		return 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map arg0, World w) {
		return this;
	}
}

/**
 * This type represents a type pattern of '*' but with an annotation specified, e.g. '@Color *'
 */
class AnyWithAnnotationTypePattern extends TypePattern {

	public AnyWithAnnotationTypePattern(AnnotationTypePattern atp) {
		super(false, false);
		annotationPattern = atp;
	}

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

	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return true;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type) {
		annotationPattern.resolve(type.getWorld());
		boolean b = false;
		if (type.temporaryAnnotationTypes != null) {
			b = annotationPattern.matches(type, type.temporaryAnnotationTypes).alwaysTrue();
		} else {
			b = annotationPattern.matches(type).alwaysTrue();
		}
		return b;
	}

	@Override
	public TypePattern resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType) {
		if (requireExactType) {
			scope.getWorld().getMessageHandler().handleMessage(
					MessageUtil.error(WeaverMessages.format(WeaverMessages.WILDCARD_NOT_ALLOWED), getSourceLocation()));
			return NO;
		}
		return super.resolveBindings(scope, bindings, allowBinding, requireExactType);
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		annotationPattern.resolve(type.getWorld());
		return annotationPattern.matches(annotatedType).alwaysTrue();
	}

	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		if (Modifier.isFinal(type.getModifiers())) {
			return FuzzyBoolean.fromBoolean(matchesExactly(type));
		}
		return FuzzyBoolean.MAYBE;
	}

	@Override
	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
		AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(this.annotationPattern.parameterizeWith(
				typeVariableMap, w));
		ret.copyLocationFrom(this);
		return ret;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(TypePattern.ANY_WITH_ANNO);
		annotationPattern.write(s);
		writeLocation(s);
	}

	public static TypePattern read(VersionedDataInputStream s, ISourceContext c) throws IOException {
		AnnotationTypePattern annPatt = AnnotationTypePattern.read(s, c);
		AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(annPatt);
		ret.readLocation(c, s);
		return ret;
	}

	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }

	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return true;
	}

	@Override
	public boolean isStar() {
		return false;
	}

	@Override
	public String toString() {
		return "(" + annotationPattern + " *)";
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof AnyWithAnnotationTypePattern)) {
			return false;
		}
		AnyWithAnnotationTypePattern awatp = (AnyWithAnnotationTypePattern) obj;
		return (annotationPattern.equals(awatp.annotationPattern));
	}

	@Override
	public int hashCode() {
		return annotationPattern.hashCode();
	}
}

class NoTypePattern extends TypePattern {

	public NoTypePattern() {
		super(false, false, new TypePatternList());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
	 */
	@Override
	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
	 */
	@Override
	protected boolean matchesExactly(ResolvedType type) {
		return false;
	}

	@Override
	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
		return false;
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
	 */
	@Override
	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
		return FuzzyBoolean.NO;
	}

	@Override
	public void write(CompressingDataOutputStream s) throws IOException {
		s.writeByte(NO_KEY);
	}

	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
	 */
	// public FuzzyBoolean matches(IType type, MatchKind kind) {
	// return FuzzyBoolean.YES;
	// }
	/**
	 * @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
	 */
	@Override
	protected boolean matchesSubtypes(ResolvedType type) {
		return false;
	}

	@Override
	public boolean isStar() {
		return false;
	}

	@Override
	public String toString() {
		return "<nothing>";
	}// FIXME AV - bad! toString() cannot be parsed back (not idempotent)

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		return (obj instanceof NoTypePattern);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		return 17 * 37 * 37;
	}

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

	@Override
	public TypePattern parameterizeWith(Map arg0, World w) {
		return this;
	}
}

Return to bug 329268

Lines 1-5 Link Here

(-)src/org/aspectj/org/eclipse/jdt/core/dom/AjASTMatcher.java (-1 / +125 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 258-261 Link Here
258	}	258	}
259	return node.getDetail().equals(((SignaturePattern) other).getDetail());	259	return node.getDetail().equals(((SignaturePattern) other).getDetail());
260	}	260	}
		261
		262	public boolean match(AndTypePattern node, Object other) {
		263	if (node == other) {
		264	return true;
		265	}
		266	if (!(other instanceof AndTypePattern)) {
		267	return false;
		268	}
		269	AndTypePattern otherBoolean = (AndTypePattern) other;
		270	return safeSubtreeMatch(node.getLeft(), otherBoolean.getLeft())
		271	&& safeSubtreeMatch(node.getRight(), otherBoolean.getRight());
		272	}
		273
		274	public boolean match(OrTypePattern node, Object other) {
		275	if (node == other) {
		276	return true;
		277	}
		278	if (!(other instanceof OrTypePattern)) {
		279	return false;
		280	}
		281	OrTypePattern otherBoolean = (OrTypePattern) other;
		282	return safeSubtreeMatch(node.getLeft(), otherBoolean.getLeft())
		283	&& safeSubtreeMatch(node.getRight(), otherBoolean.getRight());
		284	}
		285
		286	public boolean match(AnyTypePattern node, Object other) {
		287	// AnyTypePattern nodes don't hold state aside from the AST, so just do a reference check
		288	if (node == other) {
		289	return true;
		290	}
		291	return false;
		292	}
		293
		294	public boolean match(AnyWithAnnotationTypePattern node, Object other) {
		295	if (node == other) {
		296	return true;
		297	}
		298	if (!(other instanceof AnyWithAnnotationTypePattern)) {
		299	return false;
		300	}
		301	// For now only do an expression matching. In future versions, when
		302	// the node supports AnnotationTypes, this may have to be changed
		303	return node.getTypePatternExpression().equals(
		304	((AnyWithAnnotationTypePattern) other)
		305	.getTypePatternExpression());
		306	}
		307
		308	public boolean match(EllipsisTypePattern node, Object other) {
		309	// Ellipsis nodes don't hold state aside from the AST, so just do a reference check
		310	if (node == other) {
		311	return true;
		312	}
		313	return false;
		314	}
		315
		316	public boolean match(NotTypePattern node, Object other) {
		317	if (node == other) {
		318	return true;
		319	}
		320	if (!(other instanceof NotTypePattern)) {
		321	return false;
		322	}
		323	return safeSubtreeMatch(node.getNegatedTypePattern(),
		324	((NotTypePattern) other).getNegatedTypePattern());
325	}
326
327	public boolean match(NoTypePattern node, Object other) {
328	// NoTypePattern nodes don't hold state aside from the AST, so just do a reference check
329	if (node == other) {
330	return true;
331	}
332	return false;
333	}
334
335	public boolean match(HasMemberTypePattern node, Object other) {
336	if (node == other) {
337	return true;
338	}
339	if (!(other instanceof HasMemberTypePattern)) {
340	return false;
341	}
342	return safeSubtreeMatch(node.getSignaturePattern(),
343	((HasMemberTypePattern) other).getSignaturePattern());
344	}
345
346	public boolean match(IdentifierTypePattern node, Object other) {
347	if (node == other) {
348	return true;
349	}
350	if (!(other instanceof IdentifierTypePattern)) {
351	return false;
352	}
353	return safeSubtreeMatch(node.getType(),
354	((IdentifierTypePattern) other).getType());
355	}
356
357	public boolean match(TypeCategoryTypePattern node, Object other) {
358	if (node == other) {
359	return true;
360	}
361	if (!(other instanceof TypeCategoryTypePattern)) {
362	return false;
363	}
364	return node.getTypeCategory() == ((TypeCategoryTypePattern) other)
365	.getTypeCategory();
366	}
367
368	public boolean match(Type type, Object other) {
369	if (type == other) {
370	return true;
371	}
372	// For now only support simple type/simple name matching. Support for
373	// other types
374	// may have to be added here
375	if (type instanceof SimpleType && other instanceof SimpleType) {
376	Name name = ((SimpleType) type).getName();
377	Name otherName = ((SimpleType) other).getName();
378	if (name instanceof SimpleName && otherName instanceof SimpleName) {
379	return ((SimpleName) name).getIdentifier().equals(
380	((SimpleName) otherName).getIdentifier());
381	}
382	}
383	return false;
384	}
261	}	385	}

Lines 1-5 Link Here

(-)src/org/aspectj/org/eclipse/jdt/core/dom/AjASTVisitor.java (-1 / +85 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 244-247 Link Here
244		244
245	public void endVisit(SignaturePattern node) {	245	public void endVisit(SignaturePattern node) {
246	}	246	}
		247
		248	/*
		249	* TODO: if necessary split this into the two specialised
		250	* boolean type patterns (AndTypePattern, OrTypePattern)
		251	*/
		252	public boolean visit(AbstractBooleanTypePattern node) {
		253	return true;
		254	}
		255
		256	public void endVisit(AbstractBooleanTypePattern node) {
		257
		258	}
		259
		260	public boolean visit(AnyTypePattern node) {
		261	return true;
		262	}
		263
		264	public void endVisit(AnyTypePattern node) {
		265
		266	}
		267
		268	public boolean visit(AnyWithAnnotationTypePattern node) {
		269	return true;
		270	}
		271
		272	public void endVisit(AnyWithAnnotationTypePattern node) {
		273
		274	}
		275
		276	public boolean visit(EllipsisTypePattern node) {
		277	return true;
		278	}
		279
		280	public void endVisit(EllipsisTypePattern node) {
		281
		282	}
		283
		284	public boolean visit(HasMemberTypePattern node) {
		285	return true;
		286	}
		287
		288	public void endVisit(HasMemberTypePattern node) {
		289
		290	}
		291
		292	public boolean visit(IdentifierTypePattern node) {
		293	return true;
		294	}
		295
		296	public void endVisit(IdentifierTypePattern node) {
		297
		298	}
		299
		300	public boolean visit(NotTypePattern node) {
		301	return true;
		302	}
		303
		304	public void endVisit(NotTypePattern node) {
		305
		306	}
		307
		308	public boolean visit(NoTypePattern node) {
		309	return true;
		310	}
311
312	public void endVisit(NoTypePattern node) {
313
314	}
315
316	public boolean visit(TypeCategoryTypePattern node) {
317	return true;
318	}
319
320	public void endVisit(TypeCategoryTypePattern node) {
321
322	}
323
324	public boolean visit(Type node) {
325	return true;
326	}
327
328	public void endVisit(Type node) {
329
330	}
247	}	331	}

Added Link Here

(-)src/org/aspectj/org/eclipse/jdt/core/dom/AbstractBooleanTypePattern.java (+36 lines)
1	/********************************************************************
2	* Copyright (c) 2010 Contributors. All rights reserved.
3	* This program and the accompanying materials are made available
4	* under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution and is available at
6	* http://eclipse.org/legal/epl-v10.html
7	*
8	* Contributors: Nieraj Singh - initial implementation
9	*******************************************************************/
10	package org.aspectj.org.eclipse.jdt.core.dom;
11
12	public abstract class AbstractBooleanTypePattern extends TypePattern {
13
14	private TypePattern left;
15	private TypePattern right;
16
17	AbstractBooleanTypePattern(AST ast, TypePattern left, TypePattern right,
18	String booleanOperator) {
19	super(ast, booleanOperator);
20	this.left = left;
21	this.right = right;
22	}
23
24	public TypePattern getLeft() {
25	return left;
26	}
27
28	public TypePattern getRight() {
29	return right;
30	}
31
32	int treeSize() {
33	return memSize() + (this.left == null ? 0 : getLeft().treeSize())
34	+ (this.right == null ? 0 : getRight().treeSize());
35	}
36	}

Lines 1-5 Link Here

(-)testsrc/org/aspectj/tools/ajc/ASTVisitorTest.java (-12 / +154 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 17-31 Link Here
17		17
18	import org.aspectj.org.eclipse.jdt.core.dom.AST;	18	import org.aspectj.org.eclipse.jdt.core.dom.AST;
19	import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;	19	import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;
		20	import org.aspectj.org.eclipse.jdt.core.dom.AbstractBooleanTypePattern;
20	import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;	21	import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;
21	import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;	22	import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;
22	import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;	23	import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;
23	import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;	24	import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;
24	import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;	25	import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;
		26	import org.aspectj.org.eclipse.jdt.core.dom.AndTypePattern;
		27	import org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern;
		28	import org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern;
25	import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;	29	import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;
26	import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;	30	import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;
27	import org.aspectj.org.eclipse.jdt.core.dom.Assignment;	31	import org.aspectj.org.eclipse.jdt.core.dom.Assignment;
28	import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;	32	import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;
		33	import org.aspectj.org.eclipse.jdt.core.dom.BindingTypePattern;
29	import org.aspectj.org.eclipse.jdt.core.dom.Block;	34	import org.aspectj.org.eclipse.jdt.core.dom.Block;
30	import org.aspectj.org.eclipse.jdt.core.dom.BlockComment;	35	import org.aspectj.org.eclipse.jdt.core.dom.BlockComment;
31	import org.aspectj.org.eclipse.jdt.core.dom.BodyDeclaration;	36	import org.aspectj.org.eclipse.jdt.core.dom.BodyDeclaration;
Lines 39-56 Link Here
39	import org.aspectj.org.eclipse.jdt.core.dom.DeclarePrecedenceDeclaration;	44	import org.aspectj.org.eclipse.jdt.core.dom.DeclarePrecedenceDeclaration;
40	import org.aspectj.org.eclipse.jdt.core.dom.DeclareSoftDeclaration;	45	import org.aspectj.org.eclipse.jdt.core.dom.DeclareSoftDeclaration;
41	import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;	46	import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;
42	import org.aspectj.org.eclipse.jdt.core.dom.DefaultTypePattern;
43	import org.aspectj.org.eclipse.jdt.core.dom.EnumDeclaration;	47	import org.aspectj.org.eclipse.jdt.core.dom.EnumDeclaration;
		48	import org.aspectj.org.eclipse.jdt.core.dom.ExactTypePattern;
44	import org.aspectj.org.eclipse.jdt.core.dom.ExpressionStatement;	49	import org.aspectj.org.eclipse.jdt.core.dom.ExpressionStatement;
45	import org.aspectj.org.eclipse.jdt.core.dom.FieldAccess;	50	import org.aspectj.org.eclipse.jdt.core.dom.FieldAccess;
46	import org.aspectj.org.eclipse.jdt.core.dom.FieldDeclaration;	51	import org.aspectj.org.eclipse.jdt.core.dom.FieldDeclaration;
		52	import org.aspectj.org.eclipse.jdt.core.dom.IdentifierTypePattern;
47	import org.aspectj.org.eclipse.jdt.core.dom.InfixExpression;	53	import org.aspectj.org.eclipse.jdt.core.dom.InfixExpression;
48	import org.aspectj.org.eclipse.jdt.core.dom.Initializer;	54	import org.aspectj.org.eclipse.jdt.core.dom.Initializer;
49	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;	55	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;
50	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;	56	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;
51	import org.aspectj.org.eclipse.jdt.core.dom.MethodDeclaration;	57	import org.aspectj.org.eclipse.jdt.core.dom.MethodDeclaration;
52	import org.aspectj.org.eclipse.jdt.core.dom.MethodInvocation;	58	import org.aspectj.org.eclipse.jdt.core.dom.MethodInvocation;
		59	import org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern;
53	import org.aspectj.org.eclipse.jdt.core.dom.NumberLiteral;	60	import org.aspectj.org.eclipse.jdt.core.dom.NumberLiteral;
		61	import org.aspectj.org.eclipse.jdt.core.dom.OrTypePattern;
54	import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;	62	import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;
55	import org.aspectj.org.eclipse.jdt.core.dom.PerObject;	63	import org.aspectj.org.eclipse.jdt.core.dom.PerObject;
56	import org.aspectj.org.eclipse.jdt.core.dom.PerTypeWithin;	64	import org.aspectj.org.eclipse.jdt.core.dom.PerTypeWithin;
Lines 61-69 Link Here
61	import org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern;	69	import org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern;
62	import org.aspectj.org.eclipse.jdt.core.dom.SimpleName;	70	import org.aspectj.org.eclipse.jdt.core.dom.SimpleName;
63	import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;	71	import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;
		72	import org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern;
64	import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;	73	import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;
65	import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclaration;	74	import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclaration;
66	import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclarationStatement;	75	import org.aspectj.org.eclipse.jdt.core.dom.VariableDeclarationStatement;
		76	import org.aspectj.org.eclipse.jdt.core.dom.WildTypePattern;
67	import org.aspectj.org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	77	import org.aspectj.org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
68		78
69	public class ASTVisitorTest extends TestCase {	79	public class ASTVisitorTest extends TestCase {
Lines 280-289 Link Here
280	"(compilationUnit(class(simpleName)(method(primitiveType)(simpleName)(block(expressionStatement(methodInvocation(simpleName))))))(aspect(simpleName)(constructorITD(primitiveType)(simpleName)(block))))");	290	"(compilationUnit(class(simpleName)(method(primitiveType)(simpleName)(block(expressionStatement(methodInvocation(simpleName))))))(aspect(simpleName)(constructorITD(primitiveType)(simpleName)(block))))");
281	}	291	}
282		292
283	public void testDeclareParents(){	293	/*
		294	*
		295	* START: Test TypePattern nodes introduced in Bugzilla 329268.
		296	*
		297	*/
		298
		299	public void testDeclareParents() {
284	check("class A{}class B{}aspect C {declare parents : A extends B;}",	300	check("class A{}class B{}aspect C {declare parents : A extends B;}",
285	"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents(defaultTypePattern)(defaultTypePattern))))");	301	"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents(wildTypePattern)(wildTypePattern))))");
		302	}
		303
		304	public void testDeclareParentsAnyTypePattern() {
		305	check("class A{}class B{}aspect C {declare parents : * extends B;}",
		306	"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents(anyTypePattern)(wildTypePattern))))");
		307	}
		308
		309	public void testDeclareParentsAndTypePattern() {
		310	check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && B && D extends E;}",
		311	"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern((wildTypePattern)andTypePattern(wildTypePattern)))(wildTypePattern))))");
		312	}
		313
		314	public void testDeclareParentsOrTypePattern() {
		315	check("class A{}class B{}class D{}class E{}aspect C {declare parents : A \|\| B \|\| D extends E;}",
		316	"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)orTypePattern((wildTypePattern)orTypePattern(wildTypePattern)))(wildTypePattern))))");
		317	}
		318
		319	public void testDeclareParentsAndOrTypePattern() {
		320	check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && (B \|\| D) extends E;}",
		321	"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern((wildTypePattern)orTypePattern(wildTypePattern)))(wildTypePattern))))");
		322	}
		323
		324	public void testDeclareParentsOrAndTypePattern() {
		325	check("class A{}class B{}class D{}class E{}aspect C {declare parents : A \|\| B && D extends E;}",
		326	"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)orTypePattern((wildTypePattern)andTypePattern(wildTypePattern)))(wildTypePattern))))");
		327	}
		328
		329	public void testDeclareParentsNotTypePattern() {
		330	check("class A{}class B{}class D{}class E{}aspect C {declare parents : A && !B extends E;}",
		331	"(compilationUnit(class(simpleName))(class(simpleName))(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(notTypePattern(wildTypePattern)))(wildTypePattern))))");
		332	}
		333
		334	public void testDeclareParentsTypeCategoryTypePattern() {
		335	check("class A{}class E{}aspect C {declare parents : A && is(ClassType) extends E;}",
		336	"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(typeCategoryTypePattern))(wildTypePattern))))");
		337	}
		338
		339	public void testDeclareParentsTypeCategoryTypePatternNot() {
		340	check("class A{}class E{}aspect C {declare parents : A && !is(InnerType) extends E;}",
		341	"(compilationUnit(class(simpleName))(class(simpleName))(aspect(simpleName)(declareParents((wildTypePattern)andTypePattern(notTypePattern(typeCategoryTypePattern)))(wildTypePattern))))");
		342	}
		343
		344	public void testDeclareParentsAnyWithAnnotationTypePattern() {
		345	check("class E{}aspect C {declare parents : (@AnnotationT *) extends E;}",
		346	"(compilationUnit(class(simpleName))(aspect(simpleName)(declareParents(anyWithAnnotationTypePattern)(wildTypePattern))))");
286	}	347	}
		348
		349
		350	/*
		351	*
		352	* END: Test TypePattern nodes introduced in Bugzilla 329268.
		353	*
		354	*/
		355
		356
287	public void testDeclareWarning(){	357	public void testDeclareWarning(){
288	check("aspect A {pointcut a();declare warning: a(): \"warning\";}",	358	check("aspect A {pointcut a();declare warning: a(): \"warning\";}",
289	"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareWarning(referencePointcut(simpleName))(stringLiteral))))");	359	"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareWarning(referencePointcut(simpleName))(stringLiteral))))");
Lines 294-308 Link Here
294	}	364	}
295	public void testDeclareSoft(){	365	public void testDeclareSoft(){
296	check("aspect A {pointcut a();declare soft: Exception+: a();}",	366	check("aspect A {pointcut a();declare soft: Exception+: a();}",
297	"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareSoft(referencePointcut(simpleName))(defaultTypePattern))))");	367	"(compilationUnit(aspect(simpleName)(pointcut(simpleName))(declareSoft(referencePointcut(simpleName))(wildTypePattern))))");
298	}	368	}
299	public void testDeclarePrecedence(){	369	public void testDeclarePrecedence(){
300	check("aspect A{}aspect B{declare precedence: B,A;}",	370	check("aspect A{}aspect B{declare precedence: B,A;}",
301	"(compilationUnit(aspect(simpleName))(aspect(simpleName)(declarePrecedence(defaultTypePattern)(defaultTypePattern))))");	371	"(compilationUnit(aspect(simpleName))(aspect(simpleName)(declarePrecedence(wildTypePattern)(wildTypePattern))))");
302	}	372	}
303	public void testDeclareAnnotationType(){	373	public void testDeclareAnnotationType(){
304	checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @type: C : @MyAnnotation;}",	374	checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @type: C : @MyAnnotation;}",
305	"(compilationUnit(simpleName)(class(simpleName))(aspect(simpleName)(declareAtType(defaultTypePattern)(simpleName))))");	375	"(compilationUnit(simpleName)(class(simpleName))(aspect(simpleName)(declareAtType(wildTypePattern)(simpleName))))");
306	}	376	}
307	public void testDeclareAnnotationMethod(){	377	public void testDeclareAnnotationMethod(){
308	checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @method:public * C.*(..) : @MyAnnotation;}",	378	checkJLS3("@interface MyAnnotation{}class C{}aspect A{declare @method:public * C.*(..) : @MyAnnotation;}",
Lines 727-739 Link Here
727	public void endVisit(DeclareWarningDeclaration node) {	797	public void endVisit(DeclareWarningDeclaration node) {
728	b.append(")"); //$NON-NLS-1$	798	b.append(")"); //$NON-NLS-1$
729	}	799	}
730	public boolean visit(DefaultTypePattern node) {	800
731	b.append("(defaultTypePattern");	801	public boolean visit(AbstractBooleanTypePattern node) {
732	return isVisitingChildren();	802	b.append("(");
		803	node.getLeft().accept(this);
		804	if (node instanceof AndTypePattern) {
		805	b.append("andTypePattern");
		806	} else if (node instanceof OrTypePattern) {
		807	b.append("orTypePattern");
		808	}
		809	node.getRight().accept(this);
		810	b.append(")");
		811
		812	// Don't visit the children, as that is done above in order (left node first, boolean operator next, right node last
		813	return false;
733	}	814	}
734	public void endVisit(DefaultTypePattern node) {	815
735	b.append(")"); //$NON-NLS-1$	816
		817	public boolean visit(AnyTypePattern node) {
		818	b.append("(anyTypePattern");
		819	return isVisitingChildren();
736	}	820	}
		821
		822
		823	public void endVisit(AnyTypePattern node) {
		824	b.append(")");
		825	}
		826
		827
		828	public boolean visit(AnyWithAnnotationTypePattern node) {
		829	b.append("(anyWithAnnotationTypePattern");
		830	return isVisitingChildren();
		831	}
		832
		833
		834	public void endVisit(AnyWithAnnotationTypePattern node) {
		835	b.append(")");
		836	}
		837
		838	public boolean visit(IdentifierTypePattern node) {
		839	if (node instanceof WildTypePattern) {
		840	b.append("(wildTypePattern");
		841	} else if (node instanceof ExactTypePattern) {
		842	b.append("(exactTypePattern");
		843	} else if (node instanceof BindingTypePattern) {
		844	b.append("(bindingTypePattern");
		845	}
		846	return isVisitingChildren();
		847	}
		848
		849
		850	public void endVisit(IdentifierTypePattern node) {
		851	b.append(")");
		852	}
		853
		854
		855	public boolean visit(NotTypePattern node) {
		856	b.append("(notTypePattern");
		857	return isVisitingChildren();
		858	}
		859
		860
		861	public void endVisit(NotTypePattern node) {
		862	b.append(")");
		863	}
		864
		865
		866	public boolean visit(TypeCategoryTypePattern node) {
		867	b.append("(typeCategoryTypePattern");
		868	return isVisitingChildren();
		869	}
		870
		871
		872	public void endVisit(TypeCategoryTypePattern node) {
		873	b.append(")");
		874	}
		875
		876
		877	// End of TypePattern additions for Bugzilla 329268
		878
737	public boolean visit(SignaturePattern node) {	879	public boolean visit(SignaturePattern node) {
738	b.append("(signaturePattern");	880	b.append("(signaturePattern");
739	return isVisitingChildren();	881	return isVisitingChildren();

Lines 1-15 Link Here

(-)testsrc/org/aspectj/tools/ajc/AjASTTest.java (-3 / +240 lines)
1	/********************************************************************	1	/********************************************************************
2	* Copyright (c) 2006 Contributors. All rights reserved.	2	* Copyright (c) 2006, 2010 Contributors. All rights reserved.
3	* This program and the accompanying materials are made available	3	* This program and the accompanying materials are made available
4	* under the terms of the Eclipse Public License v1.0	4	* under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution and is available at	5	* which accompanies this distribution and is available at
6	* http://eclipse.org/legal/epl-v10.html	6	* http://eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors: IBM Corporation - initial API and implementation	8	* Contributors: IBM Corporation - initial API and implementation
9	* Helen Hawkins - iniital version	9	* Helen Hawkins - initial version
10	*******************************************************************/	10	*******************************************************************/
11	package org.aspectj.tools.ajc;	11	package org.aspectj.tools.ajc;
12		12
		13	import java.util.ArrayList;
13	import java.util.Collections;	14	import java.util.Collections;
14	import java.util.Iterator;	15	import java.util.Iterator;
15	import java.util.List;	16	import java.util.List;
Lines 17-22 Link Here
17	import org.aspectj.org.eclipse.jdt.core.dom.AST;	18	import org.aspectj.org.eclipse.jdt.core.dom.AST;
18	import org.aspectj.org.eclipse.jdt.core.dom.ASTNode;	19	import org.aspectj.org.eclipse.jdt.core.dom.ASTNode;
19	import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;	20	import org.aspectj.org.eclipse.jdt.core.dom.ASTParser;
		21	import org.aspectj.org.eclipse.jdt.core.dom.AbstractBooleanTypePattern;
20	import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;	22	import org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration;
21	import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;	23	import org.aspectj.org.eclipse.jdt.core.dom.AfterReturningAdviceDeclaration;
22	import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;	24	import org.aspectj.org.eclipse.jdt.core.dom.AfterThrowingAdviceDeclaration;
Lines 24-29 Link Here
24	import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;	26	import org.aspectj.org.eclipse.jdt.core.dom.AjASTVisitor;
25	import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;	27	import org.aspectj.org.eclipse.jdt.core.dom.AjTypeDeclaration;
26	import org.aspectj.org.eclipse.jdt.core.dom.AndPointcut;	28	import org.aspectj.org.eclipse.jdt.core.dom.AndPointcut;
		29	import org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern;
		30	import org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern;
27	import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;	31	import org.aspectj.org.eclipse.jdt.core.dom.AroundAdviceDeclaration;
28	import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;	32	import org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration;
29	import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;	33	import org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration;
Lines 43-53 Link Here
43	import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;	47	import org.aspectj.org.eclipse.jdt.core.dom.DeclareWarningDeclaration;
44	import org.aspectj.org.eclipse.jdt.core.dom.DefaultPointcut;	48	import org.aspectj.org.eclipse.jdt.core.dom.DefaultPointcut;
45	import org.aspectj.org.eclipse.jdt.core.dom.DefaultTypePattern;	49	import org.aspectj.org.eclipse.jdt.core.dom.DefaultTypePattern;
		50	import org.aspectj.org.eclipse.jdt.core.dom.EllipsisTypePattern;
		51	import org.aspectj.org.eclipse.jdt.core.dom.HasMemberTypePattern;
46	import org.aspectj.org.eclipse.jdt.core.dom.IExtendedModifier;	52	import org.aspectj.org.eclipse.jdt.core.dom.IExtendedModifier;
		53	import org.aspectj.org.eclipse.jdt.core.dom.IdentifierTypePattern;
47	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;	54	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration;
48	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;	55	import org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration;
49	import org.aspectj.org.eclipse.jdt.core.dom.Javadoc;	56	import org.aspectj.org.eclipse.jdt.core.dom.Javadoc;
		57	import org.aspectj.org.eclipse.jdt.core.dom.NoTypePattern;
50	import org.aspectj.org.eclipse.jdt.core.dom.NotPointcut;	58	import org.aspectj.org.eclipse.jdt.core.dom.NotPointcut;
		59	import org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern;
51	import org.aspectj.org.eclipse.jdt.core.dom.OrPointcut;	60	import org.aspectj.org.eclipse.jdt.core.dom.OrPointcut;
52	import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;	61	import org.aspectj.org.eclipse.jdt.core.dom.PerCflow;
53	import org.aspectj.org.eclipse.jdt.core.dom.PerObject;	62	import org.aspectj.org.eclipse.jdt.core.dom.PerObject;
Lines 62-69 Link Here
62	import org.aspectj.org.eclipse.jdt.core.dom.SingleVariableDeclaration;	71	import org.aspectj.org.eclipse.jdt.core.dom.SingleVariableDeclaration;
63	import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;	72	import org.aspectj.org.eclipse.jdt.core.dom.StringLiteral;
64	import org.aspectj.org.eclipse.jdt.core.dom.Type;	73	import org.aspectj.org.eclipse.jdt.core.dom.Type;
		74	import org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern;
65	import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;	75	import org.aspectj.org.eclipse.jdt.core.dom.TypeDeclaration;
66	import org.aspectj.org.eclipse.jdt.core.dom.TypePattern;	76	import org.aspectj.org.eclipse.jdt.core.dom.TypePattern;
		77	import org.aspectj.org.eclipse.jdt.internal.core.SourceRange;
67		78
68	/**	79	/**
69	* For each AspectJ ASTNode there is a test for:	80	* For each AspectJ ASTNode there is a test for:
Lines 1649-1655 Link Here
1649	public void testDeclareParents() {	1660	public void testDeclareParents() {
1650	checkJLS3("class A{}class B{}aspect C {declare parents : A extends B;}", 28, 29);	1661	checkJLS3("class A{}class B{}aspect C {declare parents : A extends B;}", 28, 29);
1651	}	1662	}
1652		1663
		1664
		1665	/*
		1666	*
		1667	*
		1668	* START: Test TypePattern nodes introduced in Bugzilla 329268.
		1669	*
		1670	*
		1671	*/
		1672
		1673	public void testDeclareParentsTypePatternNodeSource() {
		1674	checkTypePatternSourceRangesJLS3("class A{}class B{}aspect C {declare parents : A extends B;}", new int[][] {{46, 1} , {56, 1 }});
		1675	}
		1676
		1677	public void testDeclareParentsAnySource() {
		1678	checkTypePatternSourceRangesJLS3("class A{}class B{}aspect C {declare parents : * extends B;}", new int[][] {{46, 1} , {56, 1 }});
		1679	}
		1680
		1681	public void testDeclareParentsAndSource() {
		1682
		1683	checkTypePatternSourceRangesJLS3(
		1684	"class A{}class B{}class D{}class E{}aspect C {declare parents : A && B && D extends E;}",
		1685	new int[][] { { 64, 11 },// A && B && D,
		1686	{ 64, 1 }, // A
		1687	{ 69, 6 }, // B && D
		1688	{ 69, 1 }, // B
		1689	{ 74, 1 }, // D
		1690	{ 84, 1 } // E
		1691	});
		1692	}
		1693
		1694	public void testDeclareParentsNotSource() {
		1695
		1696	checkTypePatternSourceRangesJLS3(
		1697	"class A{}class B{}class D{}class E{}aspect C {declare parents : A && !B extends E;}",
		1698	new int[][] { { 64, 7 },// A && !B
		1699	{ 64, 1 }, // A
		1700	{ 70, 1 }, // !B: the source location for a negated pattern is the start of the negated pattern excluding "!". Is this a bug?
		1701	{ 70, 1 }, // B
		1702	{ 80, 1 } // E
		1703	});
		1704	}
		1705
		1706	public void testDeclareParentsOrSource() {
		1707	checkTypePatternSourceRangesJLS3(
		1708	"class A{}class B{}class D{}class E{}aspect C {declare parents : A \|\| B \|\| D extends E;}",
		1709	new int[][] { { 64, 11 },// A \|\| B \|\| D,
		1710	{ 64, 1 }, // A
		1711	{ 69, 6 }, // B \|\| D
		1712	{ 69, 1 }, // B
		1713	{ 74, 1 }, // D
		1714	{ 84, 1 } // E
		1715	});
		1716	}
		1717
		1718	public void testDeclareParentsAnyWithAnnotationSource() {
		1719	checkTypePatternSourceRangesJLS3(
		1720	"@interface AnnotationT {}class E{}aspect C {declare parents : (@AnnotationT *) extends E;}",
		1721	new int[][] { { 62, 16 },// (@AnnotationT *)
		1722	{ 87, 1 } // E
		1723	});
		1724
		1725	}
		1726
		1727	public void testDeclareParentsTypeCategorySource() {
1728	checkTypePatternSourceRangesJLS3(
1729	"class A{}class E{}aspect C {declare parents : A && is(ClassType) extends E;}",
1730	new int[][] { { 46, 18 },// A && !is(InnerType)
1731	{ 46, 1 }, // A
1732	{ 51, 13}, // is(InnerType)
1733	{ 73, 1 } // E
1734	});
1735	}
1736
1737	public void testDeclareParentsTypeCategoryNotSource() {
1738	checkTypePatternSourceRangesJLS3(
1739	"class A{}class E{}aspect C {declare parents : A && !is(InnerType) extends E;}",
1740	new int[][] { { 46, 19 },// A && !is(InnerType)
1741	{ 46, 1 }, // A
1742	{ 52, 13}, // !is(InnerType): the source location for a negated pattern is the start of the negated pattern excluding "!". Is this a bug?
1743	{ 52, 13}, // is(InnerType)
1744	{ 74, 1 } // E
1745	});
1746	}
1747
1748	// // TODO: commenting out as there isn't proper support for hasmethod(..)
1749	// yet. Uncomment and fix when hasmethod is supported
1750	// public void testDeclareParentsHasMember() {
1751	// // This is wrong. Call checkTypePatternJLS3 instead to check the source
1752	// ranges for hasMethod...
1753	// checkJLS3("class A{}class B{ public void fooB() {}}class D{}aspect C {declare parents : A && hasmethod(void foo*(..)) extends D;}",
1754	// 37, 34);
1755	// }
1756
1757	public void testDeclareParentsTypeCategoryInner() {
1758	checkCategoryTypePatternJLS3(
1759	"class A{class B{}}class E{}aspect C {declare parents : B && is(InnerType) extends E;}",
1760	TypeCategoryTypePattern.INNER, "is(InnerType)");
1761	}
1762
1763	public void testDeclareParentsTypeCategoryInterface() {
1764	checkCategoryTypePatternJLS3(
1765	"interface B{}interface E{}aspect C {declare parents : B && is(InterfaceType) extends E;}",
1766	TypeCategoryTypePattern.INTERFACE, "is(InterfaceType)");
1767	}
1768
1769	public void testDeclareParentsTypeCategoryClass() {
1770	checkCategoryTypePatternJLS3(
1771	"class B{}class E{}aspect C {declare parents : B && is(ClassType) extends E;}",
1772	TypeCategoryTypePattern.CLASS, "is(ClassType)");
1773	}
1774
1775	public void testDeclareParentsTypeCategoryAnnotation() {
1776	checkCategoryTypePatternJLS3(
1777	"@interface B{}class E{}aspect C {declare parents : B && is(AnnotationType) extends E;}",
1778	TypeCategoryTypePattern.ANNOTATION, "is(AnnotationType)");
1779	}
1780
1781	public void testDeclareParentsTypeCategoryAnonymous() {
1782	checkCategoryTypePatternJLS3(
1783	"class A{B annonymousB = new B() {};}class B{}class E{}aspect C {declare parents : B && is(AnonymousType) extends E;}",
1784	TypeCategoryTypePattern.ANONYMOUS, "is(AnonymousType)");
1785	}
1786
1787	public void testDeclareParentsTypeCategoryEnum() {
1788	checkCategoryTypePatternJLS3(
1789	"class B{}class E{}aspect C {declare parents : B && !is(EnumType) extends E;}",
1790	TypeCategoryTypePattern.ENUM, "is(EnumType)");
1791	}
1792
1793	/*
1794	*
1795	*
1796	* END: Test TypePattern nodes introduced in Bugzilla 329268.
1797	*
1798	*
1799	*/
1800
1801
1653	public void testDeclareWarning() {	1802	public void testDeclareWarning() {
1654	checkJLS3("aspect A {pointcut a();declare warning: a(): \"error\";}", 23, 30);	1803	checkJLS3("aspect A {pointcut a();declare warning: a(): \"error\";}", 23, 30);
1655	}	1804	}
Lines 1680-1687 Link Here
1680	assertEquals("expected there to be one comment but found " + cu.getCommentList().size(), 1, cu.getCommentList().size());	1829	assertEquals("expected there to be one comment but found " + cu.getCommentList().size(), 1, cu.getCommentList().size());
1681	}	1830	}
1682		1831
		1832
		1833	protected void assertExpression(String expectedExpression, TypePattern node) {
		1834	assertTrue("Expected: " + expectedExpression + ". Actual: " + node.getTypePatternExpression(), node.getTypePatternExpression().equals(expectedExpression));
		1835
		1836	}
		1837
		1838	protected void assertNodeType(Class<?> expected, TypePattern node) {
		1839	assertTrue("Expected " + expected.toString() + ". Actual: " + node.getClass().toString(), node.getClass().equals(expected));
		1840	}
		1841	}
		1842
		1843
		1844
		1845	class TypeCategoryTypeVisitor extends AjASTVisitor {
		1846
		1847	private TypeCategoryTypePattern typeCategory = null;
		1848
		1849	public boolean visit(TypeCategoryTypePattern node) {
		1850	typeCategory = node;
		1851	return false;
		1852	}
		1853
		1854	public TypeCategoryTypePattern getTypeCategoryNode() {
		1855	return typeCategory;
		1856	}
		1857	}
		1858
		1859	class TypePatternSourceRangeVisitor extends AjASTVisitor {
		1860	private List<SourceRange> sourceRanges = new ArrayList<SourceRange>();
		1861
		1862	public List<SourceRange> getVisitedSourceRanges() {
		1863	return sourceRanges;
		1864	}
		1865
		1866	public boolean visit(AbstractBooleanTypePattern node) {
		1867	sourceRanges.add(new SourceRange(node.getStartPosition(), node
		1868	.getLength()));
		1869	return true;
		1870	}
		1871
		1872	public boolean visit(AnyTypePattern node) {
		1873	sourceRanges.add(new SourceRange(node.getStartPosition(), node
		1874	.getLength()));
		1875	return true;
		1876	}
		1877
		1878	public boolean visit(AnyWithAnnotationTypePattern node) {
		1879	sourceRanges.add(new SourceRange(node.getStartPosition(), node
		1880	.getLength()));
		1881	return true;
		1882	}
		1883
		1884	public boolean visit(EllipsisTypePattern node) {
		1885	sourceRanges.add(new SourceRange(node.getStartPosition(), node
		1886	.getLength()));
		1887	return true;
		1888	}
		1889
		1890	public boolean visit(HasMemberTypePattern node) {
		1891	sourceRanges.add(new SourceRange(node.getStartPosition(), node
		1892	.getLength()));
		1893	return true;
		1894	}
		1895
1896	public boolean visit(IdentifierTypePattern node) {
1897	sourceRanges.add(new SourceRange(node.getStartPosition(), node
1898	.getLength()));
1899	return true;
1900	}
1901
1902	public boolean visit(NotTypePattern node) {
1903	sourceRanges.add(new SourceRange(node.getStartPosition(), node
1904	.getLength()));
1905	return true;
1906	}
1907
1908	public boolean visit(NoTypePattern node) {
1909	sourceRanges.add(new SourceRange(node.getStartPosition(), node
1910	.getLength()));
1911	return true;
1912	}
1913
1914	public boolean visit(TypeCategoryTypePattern node) {
1915	sourceRanges.add(new SourceRange(node.getStartPosition(), node
1916	.getLength()));
1917	return true;
1918	}
1683	}	1919	}
1684		1920
		1921
1685	class SourceRangeVisitor extends AjASTVisitor {	1922	class SourceRangeVisitor extends AjASTVisitor {
1686		1923
1687	boolean visitTheKids = true;	1924	boolean visitTheKids = true;

Lines 1-5 Link Here

(-)testsrc/org/aspectj/tools/ajc/AjNaiveASTFlattenerTest.java (-1 / +57 lines)
1	/********************************************************************	1	/********************************************************************
2	* Copyright (c) 2006 Contributors. All rights reserved.	2	* Copyright (c) 2006, 2010 Contributors. All rights reserved.
3	* This program and the accompanying materials are made available	3	* This program and the accompanying materials are made available
4	* under the terms of the Eclipse Public License v1.0	4	* under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution and is available at	5	* which accompanies this distribution and is available at
Lines 67-72 Link Here
67	"public aspect A {\n declare parents: X extends Y;\n}\n");	67	"public aspect A {\n declare parents: X extends Y;\n}\n");
68	}	68	}
69		69
		70
		71	/*
		72	*
		73	*
		74	* START: Test TypePattern nodes introduced in Bugzilla 329268.
		75	*
		76	*
		77	*/
		78
		79	public void testDeclareParentsDeclarationAny() throws Exception {
		80	check("public aspect A { declare parents: * extends Y; }",
		81	"public aspect A {\n declare parents: * extends Y;\n}\n");
		82	}
		83
		84	public void testDeclareParentsAndDeclaration() throws Exception {
		85	check("public aspect A { declare parents: W && X && Y extends Z; }",
		86	"public aspect A {\n declare parents: W && X && Y extends Z;\n}\n");
		87	}
		88
		89	public void testDeclareParentsOrDeclaration() throws Exception {
		90	check("public aspect A { declare parents: W \|\| X \|\| Y extends Z; }",
		91	"public aspect A {\n declare parents: W \|\| X \|\| Y extends Z;\n}\n");
		92	}
		93
		94	public void testDeclareParentsNot() throws Exception {
		95	check("public aspect A { declare parents: W && !X extends Z; }",
		96	"public aspect A {\n declare parents: W && !X extends Z;\n}\n");
		97	}
		98
		99	public void testDeclareParentsTypeCategory() throws Exception {
		100	check("public aspect A { declare parents: B && is(AnonymousType) extends Z; }",
		101	"public aspect A {\n declare parents: B && is(AnonymousType) extends Z;\n}\n");
		102
		103	}
		104
		105	public void testDeclareParentsTypeCategoryNot() throws Exception {
		106	check("public aspect A { declare parents: B && !is(InnerType) extends Z; }",
		107	"public aspect A {\n declare parents: B && !is(InnerType) extends Z;\n}\n");
		108	}
		109
		110
		111	// TODO: commented until hasmethod is supported in AspectJ
		112	// public void testDeclareParentsHasMember() {
		113	// check("public aspect A { declare parents : A && hasmethod(void foo*(..)) extends D; }",
		114	// "public aspect A {\n declare parents : A && hasmethod(void foo*(..)) extends D;\n}\n");
		115	// }
		116
		117
		118	/*
		119	*
		120	*
		121	* END: Test TypePattern nodes introduced in Bugzilla 329268.
		122	*
		123	*
		124	*/
		125
70	public void testDeclareWarning() throws Exception {	126	public void testDeclareWarning() throws Exception {
71	check("public aspect A { declare warning: call(* .(..)) : \"warning!\"; }",	127	check("public aspect A { declare warning: call(* .(..)) : \"warning!\"; }",
72	"public aspect A {\n declare warning: call(* .(..)) : \"warning!\" ;\n}\n");	128	"public aspect A {\n declare warning: call(* .(..)) : \"warning!\" ;\n}\n");

Added Link Here

(-)src/org/aspectj/weaver/patterns/AnyTypePattern.java (+112 lines)
1	/* *******************************************************************
2	* Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
3	* All rights reserved.
4	* This program and the accompanying materials are made available
5	* under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* PARC initial implementation
11	* ******************************************************************/
12	package org.aspectj.weaver.patterns;
13
14	import java.io.IOException;
15	import java.util.Map;
16
17	import org.aspectj.util.FuzzyBoolean;
18	import org.aspectj.weaver.CompressingDataOutputStream;
19	import org.aspectj.weaver.ResolvedType;
20	import org.aspectj.weaver.World;
21
22	public class AnyTypePattern extends TypePattern {
23
24	/**
25	* Constructor for EllipsisTypePattern.
26	*
27	* @param includeSubtypes
28	*/
29	public AnyTypePattern() {
30	super(false, false, new TypePatternList());
31	}
32
33	/*
34	* (non-Javadoc)
35	*
36	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
37	*/
38	@Override
39	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
40	return true;
41	}
42
43	/**
44	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
45	*/
46	@Override
47	protected boolean matchesExactly(ResolvedType type) {
48	return true;
49	}
50
51	@Override
52	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
53	return true;
54	}
55
56	/**
57	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
58	*/
59	@Override
60	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
61	return FuzzyBoolean.YES;
62	}
63
64	@Override
65	public void write(CompressingDataOutputStream s) throws IOException {
66	s.writeByte(ANY_KEY);
67	}
68
69	/**
70	* @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
71	*/
72	// public FuzzyBoolean matches(IType type, MatchKind kind) {
73	// return FuzzyBoolean.YES;
74	// }
75	/**
76	* @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
77	*/
78	@Override
79	protected boolean matchesSubtypes(ResolvedType type) {
80	return true;
81	}
82
83	@Override
84	public boolean isStar() {
85	return true;
86	}
87
88	@Override
89	public String toString() {
90	return "*";
91	}
92
93	@Override
94	public boolean equals(Object obj) {
95	return (obj instanceof AnyTypePattern);
96	}
97
98	@Override
99	public int hashCode() {
100	return 37;
101	}
102
103	@Override
104	public Object accept(PatternNodeVisitor visitor, Object data) {
105	return visitor.visit(this, data);
106	}
107
108	@Override
109	public TypePattern parameterizeWith(Map arg0, World w) {
110	return this;
111	}
112	}

Added Link Here

(-)src/org/aspectj/weaver/patterns/AnyWithAnnotationTypePattern.java (+142 lines)
1	/* *******************************************************************
2	* Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
3	* All rights reserved.
4	* This program and the accompanying materials are made available
5	* under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* PARC initial implementation
11	* ******************************************************************/
12	package org.aspectj.weaver.patterns;
13
14	import java.io.IOException;
15	import java.lang.reflect.Modifier;
16	import java.util.Map;
17
18	import org.aspectj.bridge.MessageUtil;
19	import org.aspectj.util.FuzzyBoolean;
20	import org.aspectj.weaver.CompressingDataOutputStream;
21	import org.aspectj.weaver.ISourceContext;
22	import org.aspectj.weaver.ResolvedType;
23	import org.aspectj.weaver.VersionedDataInputStream;
24	import org.aspectj.weaver.WeaverMessages;
25	import org.aspectj.weaver.World;
26
27
28	/**
29	* This type represents a type pattern of '' but with an annotation specified, e.g. '@Color '
30	*/
31	public class AnyWithAnnotationTypePattern extends TypePattern {
32
33	public AnyWithAnnotationTypePattern(AnnotationTypePattern atp) {
34	super(false, false);
35	annotationPattern = atp;
36	}
37
38	@Override
39	public Object accept(PatternNodeVisitor visitor, Object data) {
40	return visitor.visit(this, data);
41	}
42
43	@Override
44	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
45	return true;
46	}
47
48	@Override
49	protected boolean matchesExactly(ResolvedType type) {
50	annotationPattern.resolve(type.getWorld());
51	boolean b = false;
52	if (type.temporaryAnnotationTypes != null) {
53	b = annotationPattern.matches(type, type.temporaryAnnotationTypes).alwaysTrue();
54	} else {
55	b = annotationPattern.matches(type).alwaysTrue();
56	}
57	return b;
58	}
59
60	@Override
61	public TypePattern resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType) {
62	if (requireExactType) {
63	scope.getWorld().getMessageHandler().handleMessage(
64	MessageUtil.error(WeaverMessages.format(WeaverMessages.WILDCARD_NOT_ALLOWED), getSourceLocation()));
65	return NO;
66	}
67	return super.resolveBindings(scope, bindings, allowBinding, requireExactType);
68	}
69
70	@Override
71	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
72	annotationPattern.resolve(type.getWorld());
73	return annotationPattern.matches(annotatedType).alwaysTrue();
74	}
75
76	@Override
77	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
78	if (Modifier.isFinal(type.getModifiers())) {
79	return FuzzyBoolean.fromBoolean(matchesExactly(type));
80	}
81	return FuzzyBoolean.MAYBE;
82	}
83
84	@Override
85	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
86	AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(this.annotationPattern.parameterizeWith(
87	typeVariableMap, w));
88	ret.copyLocationFrom(this);
89	return ret;
90	}
91
92	@Override
93	public void write(CompressingDataOutputStream s) throws IOException {
94	s.writeByte(TypePattern.ANY_WITH_ANNO);
95	annotationPattern.write(s);
96	writeLocation(s);
97	}
98
99	public static TypePattern read(VersionedDataInputStream s, ISourceContext c) throws IOException {
100	AnnotationTypePattern annPatt = AnnotationTypePattern.read(s, c);
101	AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(annPatt);
102	ret.readLocation(c, s);
103	return ret;
104	}
105
106	// public FuzzyBoolean matches(IType type, MatchKind kind) {
107	// return FuzzyBoolean.YES;
108	// }
109
110	@Override
111	protected boolean matchesSubtypes(ResolvedType type) {
112	return true;
113	}
114
115	@Override
116	public boolean isStar() {
117	return false;
118	}
119
120	@Override
121	public String toString() {
122	return "(" + annotationPattern + " *)";
123	}
124
125	public AnnotationTypePattern getAnnotationTypePattern() {
126	return annotationPattern;
127	}
128
129	@Override
130	public boolean equals(Object obj) {
131	if (!(obj instanceof AnyWithAnnotationTypePattern)) {
132	return false;
133	}
134	AnyWithAnnotationTypePattern awatp = (AnyWithAnnotationTypePattern) obj;
135	return (annotationPattern.equals(awatp.annotationPattern));
136	}
137
138	@Override
139	public int hashCode() {
140	return annotationPattern.hashCode();
141	}
142	}

Lines 1-5 Link Here

(-)src/org/aspectj/weaver/patterns/BindingTypePattern.java (-1 / +7 lines)
1	/* *******************************************************************	1	/* *******************************************************************
2	* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).	2	* Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC).
3	* All rights reserved.	3	* All rights reserved.
4	* This program and the accompanying materials are made available	4	* This program and the accompanying materials are made available
5	* under the terms of the Eclipse Public License v1.0	5	* under the terms of the Eclipse Public License v1.0
Lines 25-30 Link Here
25		25
26	public class BindingTypePattern extends ExactTypePattern implements BindingPattern {	26	public class BindingTypePattern extends ExactTypePattern implements BindingPattern {
27	private int formalIndex;	27	private int formalIndex;
		28	private String bindingName;
28		29
29	public BindingTypePattern(UnresolvedType type, int index, boolean isVarArgs) {	30	public BindingTypePattern(UnresolvedType type, int index, boolean isVarArgs) {
30	super(type, false, isVarArgs);	31	super(type, false, isVarArgs);
Lines 33-43 Link Here
33		34
34	public BindingTypePattern(FormalBinding binding, boolean isVarArgs) {	35	public BindingTypePattern(FormalBinding binding, boolean isVarArgs) {
35	this(binding.getType(), binding.getIndex(), isVarArgs);	36	this(binding.getType(), binding.getIndex(), isVarArgs);
		37	this.bindingName = binding.getName();
36	}	38	}
37		39
38	public int getFormalIndex() {	40	public int getFormalIndex() {
39	return formalIndex;	41	return formalIndex;
40	}	42	}
		43
		44	public String getBindingName() {
		45	return bindingName;
		46	}
41		47
42	public boolean equals(Object other) {	48	public boolean equals(Object other) {
43	if (!(other instanceof BindingTypePattern)) {	49	if (!(other instanceof BindingTypePattern)) {

Added Link Here

(-)src/org/aspectj/weaver/patterns/EllipsisTypePattern.java (+109 lines)
1	/* *******************************************************************
2	* Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC) and others.
3	* All rights reserved.
4	* This program and the accompanying materials are made available
5	* under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* PARC initial implementation
11	* ******************************************************************/
12	package org.aspectj.weaver.patterns;
13
14	import java.io.IOException;
15	import java.util.Map;
16
17	import org.aspectj.util.FuzzyBoolean;
18	import org.aspectj.weaver.CompressingDataOutputStream;
19	import org.aspectj.weaver.ResolvedType;
20	import org.aspectj.weaver.World;
21
22	public class EllipsisTypePattern extends TypePattern {
23
24	/**
25	* Constructor for EllipsisTypePattern.
26	*
27	* @param includeSubtypes
28	*/
29	public EllipsisTypePattern() {
30	super(false, false, new TypePatternList());
31	}
32
33	/*
34	* (non-Javadoc)
35	*
36	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
37	*/
38	@Override
39	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
40	return true;
41	}
42
43	/**
44	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
45	*/
46	@Override
47	protected boolean matchesExactly(ResolvedType type) {
48	return false;
49	}
50
51	@Override
52	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
53	return false;
54	}
55
56	/**
57	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
58	*/
59	@Override
60	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
61	return FuzzyBoolean.NO;
62	}
63
64	@Override
65	public void write(CompressingDataOutputStream s) throws IOException {
66	s.writeByte(ELLIPSIS_KEY);
67	}
68
69	@Override
70	public boolean isEllipsis() {
71	return true;
72	}
73
74	@Override
75	public String toString() {
76	return "..";
77	}
78
79	/*
80	* (non-Javadoc)
81	*
82	* @see java.lang.Object#equals(java.lang.Object)
83	*/
84	@Override
85	public boolean equals(Object obj) {
86	return (obj instanceof EllipsisTypePattern);
87	}
88
89	/*
90	* (non-Javadoc)
91	*
92	* @see java.lang.Object#hashCode()
93	*/
94	@Override
95	public int hashCode() {
96	return 17 * 37;
97	}
98
99	@Override
100	public Object accept(PatternNodeVisitor visitor, Object data) {
101	return visitor.visit(this, data);
102	}
103
104	@Override
105	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
106	return this;
107	}
108
109	}

Added Link Here

(-)src/org/aspectj/weaver/patterns/NoTypePattern.java (+106 lines)
1	package org.aspectj.weaver.patterns;
2
3	import java.io.IOException;
4	import java.util.Map;
5
6	import org.aspectj.util.FuzzyBoolean;
7	import org.aspectj.weaver.CompressingDataOutputStream;
8	import org.aspectj.weaver.ResolvedType;
9	import org.aspectj.weaver.World;
10
11	public class NoTypePattern extends TypePattern {
12
13	public NoTypePattern() {
14	super(false, false, new TypePatternList());
15	}
16
17	/*
18	* (non-Javadoc)
19	*
20	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
21	*/
22	@Override
23	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
24	return false;
25	}
26
27	/**
28	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
29	*/
30	@Override
31	protected boolean matchesExactly(ResolvedType type) {
32	return false;
33	}
34
35	@Override
36	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
37	return false;
38	}
39
40	/**
41	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
42	*/
43	@Override
44	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
45	return FuzzyBoolean.NO;
46	}
47
48	@Override
49	public void write(CompressingDataOutputStream s) throws IOException {
50	s.writeByte(NO_KEY);
51	}
52
53	/**
54	* @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
55	*/
56	// public FuzzyBoolean matches(IType type, MatchKind kind) {
57	// return FuzzyBoolean.YES;
58	// }
59	/**
60	* @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
61	*/
62	@Override
63	protected boolean matchesSubtypes(ResolvedType type) {
64	return false;
65	}
66
67	@Override
68	public boolean isStar() {
69	return false;
70	}
71
72	@Override
73	public String toString() {
74	return "<nothing>";
75	}// FIXME AV - bad! toString() cannot be parsed back (not idempotent)
76
77	/*
78	* (non-Javadoc)
79	*
80	* @see java.lang.Object#equals(java.lang.Object)
81	*/
82	@Override
83	public boolean equals(Object obj) {
84	return (obj instanceof NoTypePattern);
85	}
86
87	/*
88	* (non-Javadoc)
89	*
90	* @see java.lang.Object#hashCode()
91	*/
92	@Override
93	public int hashCode() {
94	return 17 * 37 * 37;
95	}
96
97	@Override
98	public Object accept(PatternNodeVisitor visitor, Object data) {
99	return visitor.visit(this, data);
100	}
101
102	@Override
103	public TypePattern parameterizeWith(Map arg0, World w) {
104	return this;
105	}
106	}

Lines 1-5 Link Here

(-)src/org/aspectj/weaver/patterns/TypePattern.java (-390 / +1 lines)
1	/* *******************************************************************	1	/* *******************************************************************
2	* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).	2	* Copyright (c) 2002, 2010 Palo Alto Research Center, Incorporated (PARC).
3	* All rights reserved.	3	* All rights reserved.
4	* This program and the accompanying materials are made available	4	* This program and the accompanying materials are made available
5	* under the terms of the Eclipse Public License v1.0	5	* under the terms of the Eclipse Public License v1.0
Lines 13-26 Link Here
13	package org.aspectj.weaver.patterns;	13	package org.aspectj.weaver.patterns;
14		14
15	import java.io.IOException;	15	import java.io.IOException;
16	import java.lang.reflect.Modifier;
17	import java.util.Iterator;	16	import java.util.Iterator;
18	import java.util.Map;	17	import java.util.Map;
19		18
20	import org.aspectj.bridge.MessageUtil;	19	import org.aspectj.bridge.MessageUtil;
21	import org.aspectj.util.FuzzyBoolean;	20	import org.aspectj.util.FuzzyBoolean;
22	import org.aspectj.weaver.BCException;	21	import org.aspectj.weaver.BCException;
23	import org.aspectj.weaver.CompressingDataOutputStream;
24	import org.aspectj.weaver.ISourceContext;	22	import org.aspectj.weaver.ISourceContext;
25	import org.aspectj.weaver.IntMap;	23	import org.aspectj.weaver.IntMap;
26	import org.aspectj.weaver.ResolvedType;	24	import org.aspectj.weaver.ResolvedType;
Lines 357-748 Link Here
357		355
358	}	356	}
359		357
360	class EllipsisTypePattern extends TypePattern {
361		358
362	/**
363	* Constructor for EllipsisTypePattern.
364	*
365	* @param includeSubtypes
366	*/
367	public EllipsisTypePattern() {
368	super(false, false, new TypePatternList());
369	}
370
371	/*
372	* (non-Javadoc)
373	*
374	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
375	*/
376	@Override
377	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
378	return true;
379	}
380
381	/**
382	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
383	*/
384	@Override
385	protected boolean matchesExactly(ResolvedType type) {
386	return false;
387	}
388
389	@Override
390	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
391	return false;
392	}
393
394	/**
395	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
396	*/
397	@Override
398	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
399	return FuzzyBoolean.NO;
400	}
401
402	@Override
403	public void write(CompressingDataOutputStream s) throws IOException {
404	s.writeByte(ELLIPSIS_KEY);
405	}
406
407	@Override
408	public boolean isEllipsis() {
409	return true;
410	}
411
412	@Override
413	public String toString() {
414	return "..";
415	}
416
417	/*
418	* (non-Javadoc)
419	*
420	* @see java.lang.Object#equals(java.lang.Object)
421	*/
422	@Override
423	public boolean equals(Object obj) {
424	return (obj instanceof EllipsisTypePattern);
425	}
426
427	/*
428	* (non-Javadoc)
429	*
430	* @see java.lang.Object#hashCode()
431	*/
432	@Override
433	public int hashCode() {
434	return 17 * 37;
435	}
436
437	@Override
438	public Object accept(PatternNodeVisitor visitor, Object data) {
439	return visitor.visit(this, data);
440	}
441
442	@Override
443	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
444	return this;
445	}
446
447	}
448
449	class AnyTypePattern extends TypePattern {
450
451	/**
452	* Constructor for EllipsisTypePattern.
453	*
454	* @param includeSubtypes
455	*/
456	public AnyTypePattern() {
457	super(false, false, new TypePatternList());
458	}
459
460	/*
461	* (non-Javadoc)
462	*
463	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
464	*/
465	@Override
466	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
467	return true;
468	}
469
470	/**
471	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
472	*/
473	@Override
474	protected boolean matchesExactly(ResolvedType type) {
475	return true;
476	}
477
478	@Override
479	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
480	return true;
481	}
482
483	/**
484	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
485	*/
486	@Override
487	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
488	return FuzzyBoolean.YES;
489	}
490
491	@Override
492	public void write(CompressingDataOutputStream s) throws IOException {
493	s.writeByte(ANY_KEY);
494	}
495
496	/**
497	* @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
498	*/
499	// public FuzzyBoolean matches(IType type, MatchKind kind) {
500	// return FuzzyBoolean.YES;
501	// }
502	/**
503	* @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
504	*/
505	@Override
506	protected boolean matchesSubtypes(ResolvedType type) {
507	return true;
508	}
509
510	@Override
511	public boolean isStar() {
512	return true;
513	}
514
515	@Override
516	public String toString() {
517	return "*";
518	}
519
520	@Override
521	public boolean equals(Object obj) {
522	return (obj instanceof AnyTypePattern);
523	}
524
525	@Override
526	public int hashCode() {
527	return 37;
528	}
529
530	@Override
531	public Object accept(PatternNodeVisitor visitor, Object data) {
532	return visitor.visit(this, data);
533	}
534
535	@Override
536	public TypePattern parameterizeWith(Map arg0, World w) {
537	return this;
538	}
539	}
540
541	/**
542	* This type represents a type pattern of '' but with an annotation specified, e.g. '@Color '
543	*/
544	class AnyWithAnnotationTypePattern extends TypePattern {
545
546	public AnyWithAnnotationTypePattern(AnnotationTypePattern atp) {
547	super(false, false);
548	annotationPattern = atp;
549	}
550
551	@Override
552	public Object accept(PatternNodeVisitor visitor, Object data) {
553	return visitor.visit(this, data);
554	}
555
556	@Override
557	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
558	return true;
559	}
560
561	@Override
562	protected boolean matchesExactly(ResolvedType type) {
563	annotationPattern.resolve(type.getWorld());
564	boolean b = false;
565	if (type.temporaryAnnotationTypes != null) {
566	b = annotationPattern.matches(type, type.temporaryAnnotationTypes).alwaysTrue();
567	} else {
568	b = annotationPattern.matches(type).alwaysTrue();
569	}
570	return b;
571	}
572
573	@Override
574	public TypePattern resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType) {
575	if (requireExactType) {
576	scope.getWorld().getMessageHandler().handleMessage(
577	MessageUtil.error(WeaverMessages.format(WeaverMessages.WILDCARD_NOT_ALLOWED), getSourceLocation()));
578	return NO;
579	}
580	return super.resolveBindings(scope, bindings, allowBinding, requireExactType);
581	}
582
583	@Override
584	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
585	annotationPattern.resolve(type.getWorld());
586	return annotationPattern.matches(annotatedType).alwaysTrue();
587	}
588
589	@Override
590	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
591	if (Modifier.isFinal(type.getModifiers())) {
592	return FuzzyBoolean.fromBoolean(matchesExactly(type));
593	}
594	return FuzzyBoolean.MAYBE;
595	}
596
597	@Override
598	public TypePattern parameterizeWith(Map typeVariableMap, World w) {
599	AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(this.annotationPattern.parameterizeWith(
600	typeVariableMap, w));
601	ret.copyLocationFrom(this);
602	return ret;
603	}
604
605	@Override
606	public void write(CompressingDataOutputStream s) throws IOException {
607	s.writeByte(TypePattern.ANY_WITH_ANNO);
608	annotationPattern.write(s);
609	writeLocation(s);
610	}
611		359
612	public static TypePattern read(VersionedDataInputStream s, ISourceContext c) throws IOException {
613	AnnotationTypePattern annPatt = AnnotationTypePattern.read(s, c);
614	AnyWithAnnotationTypePattern ret = new AnyWithAnnotationTypePattern(annPatt);
615	ret.readLocation(c, s);
616	return ret;
617	}
618
619	// public FuzzyBoolean matches(IType type, MatchKind kind) {
620	// return FuzzyBoolean.YES;
621	// }
622
623	@Override
624	protected boolean matchesSubtypes(ResolvedType type) {
625	return true;
626	}
627
628	@Override
629	public boolean isStar() {
630	return false;
631	}
632
633	@Override
634	public String toString() {
635	return "(" + annotationPattern + " *)";
636	}
637
638	@Override
639	public boolean equals(Object obj) {
640	if (!(obj instanceof AnyWithAnnotationTypePattern)) {
641	return false;
642	}
643	AnyWithAnnotationTypePattern awatp = (AnyWithAnnotationTypePattern) obj;
644	return (annotationPattern.equals(awatp.annotationPattern));
645	}
646
647	@Override
648	public int hashCode() {
649	return annotationPattern.hashCode();
650	}
651	}
652
653	class NoTypePattern extends TypePattern {
654
655	public NoTypePattern() {
656	super(false, false, new TypePatternList());
657	}
658
659	/*
660	* (non-Javadoc)
661	*
662	* @see org.aspectj.weaver.patterns.TypePattern#couldEverMatchSameTypesAs(org.aspectj.weaver.patterns.TypePattern)
663	*/
664	@Override
665	protected boolean couldEverMatchSameTypesAs(TypePattern other) {
666	return false;
667	}
668
669	/**
670	* @see org.aspectj.weaver.patterns.TypePattern#matchesExactly(IType)
671	*/
672	@Override
673	protected boolean matchesExactly(ResolvedType type) {
674	return false;
675	}
676
677	@Override
678	protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
679	return false;
680	}
681
682	/**
683	* @see org.aspectj.weaver.patterns.TypePattern#matchesInstanceof(IType)
684	*/
685	@Override
686	public FuzzyBoolean matchesInstanceof(ResolvedType type) {
687	return FuzzyBoolean.NO;
688	}
689
690	@Override
691	public void write(CompressingDataOutputStream s) throws IOException {
692	s.writeByte(NO_KEY);
693	}
694
695	/**
696	* @see org.aspectj.weaver.patterns.TypePattern#matches(IType, MatchKind)
697	*/
698	// public FuzzyBoolean matches(IType type, MatchKind kind) {
699	// return FuzzyBoolean.YES;
700	// }
701	/**
702	* @see org.aspectj.weaver.patterns.TypePattern#matchesSubtypes(IType)
703	*/
704	@Override
705	protected boolean matchesSubtypes(ResolvedType type) {
706	return false;
707	}
708
709	@Override
710	public boolean isStar() {
711	return false;
712	}
713
714	@Override
715	public String toString() {
716	return "<nothing>";
717	}// FIXME AV - bad! toString() cannot be parsed back (not idempotent)
718
719	/*
720	* (non-Javadoc)
721	*
722	* @see java.lang.Object#equals(java.lang.Object)
723	*/
724	@Override
725	public boolean equals(Object obj) {
726	return (obj instanceof NoTypePattern);
727	}
728
729	/*
730	* (non-Javadoc)
731	*
732	* @see java.lang.Object#hashCode()
733	*/
734	@Override
735	public int hashCode() {
736	return 17 * 37 * 37;
737	}
738
739	@Override
740	public Object accept(PatternNodeVisitor visitor, Object data) {
741	return visitor.visit(this, data);
742	}
743
744	@Override
745	public TypePattern parameterizeWith(Map arg0, World w) {
746	return this;
747	}
748	}