this patch implements the MAP for aspects, pointcuts, and advice. just enough of an implementation to provide the support needed for some of the ataspectj visitor tests.

aspectj5rt/java5-src/org/aspectj/internal/lang/annotation/ajcPrivileged.java

@@ -0,0 +1,27 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.annotation;
+
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+
+/**
+ * @author colyer
+ * Marker annotation for privileged aspects.
+ * ajc prefix used to indicate that this annotation is *internal*
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface ajcPrivileged {}

aspectj5rt/java5-src/org/aspectj/internal/lang/reflect/AdviceImpl.java

@@ -0,0 +1,55 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+
+import java.lang.reflect.Method;
+
+import org.aspectj.lang.annotation.AdviceName;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.reflect.Advice;
+import org.aspectj.lang.reflect.AdviceType;
+
+/**
+ * @author colyer
+ *
+ */
+public class AdviceImpl implements Advice {
+
+	private final AdviceType kind;
+	private final Method adviceMethod;
+	private String pointcutExpression;
+	
+	protected AdviceImpl(Method method, String pointcut, AdviceType type) {
+		this.kind = type;
+		this.adviceMethod = method;
+		this.pointcutExpression = pointcut;
+	}
+	
+	public AdviceType getKind() {
+		return kind;
+	}
+	
+	public String getName() {
+		String adviceName = adviceMethod.getName();
+		if (adviceName.startsWith("ajc$")) {
+			adviceName = "";
+			AdviceName name = adviceMethod.getAnnotation(AdviceName.class);
+			if (name != null) adviceName = name.value();
+		}
+		return adviceName;
+	}
+	
+	public String getPointcutExpression() {
+		return pointcutExpression;
+	}
+	
+}

aspectj5rt/java5-src/org/aspectj/internal/lang/reflect/AjTypeImpl.java

@@ -17,10 +17,23 @@ import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
-
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+import org.aspectj.internal.lang.annotation.ajcPrivileged;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.reflect.Advice;
 import org.aspectj.lang.reflect.AdviceType;
 import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
 import org.aspectj.lang.reflect.DeclareAnnotation;
 import org.aspectj.lang.reflect.DeclareErrorOrWarning;
 import org.aspectj.lang.reflect.DeclareParents;
@@ -29,16 +42,26 @@ import org.aspectj.lang.reflect.DeclareSoft;
 import org.aspectj.lang.reflect.InterTypeConstructorDeclaration;
 import org.aspectj.lang.reflect.InterTypeFieldDeclaration;
 import org.aspectj.lang.reflect.InterTypeMethodDeclaration;
+import org.aspectj.lang.reflect.NoSuchAdviceException;
+import org.aspectj.lang.reflect.NoSuchPointcutException;
 import org.aspectj.lang.reflect.PerClause;
+import org.aspectj.lang.reflect.PerClauseKind;
 import org.aspectj.lang.reflect.Pointcut;
 
+
 /**
  * @author colyer
  *
  */
 public class AjTypeImpl<T> implements AjType {
 	
+	private static final String ajcMagic = "ajc$";
+	
 	private Class<T> clazz;
+	private Pointcut[] declaredPointcuts = null;
+	private Pointcut[] pointcuts = null;
+	private Advice[] declaredAdvice = null;
+	private Advice[] advice = null;
 	
 	public AjTypeImpl(Class<T> fromClass) {
 		this.clazz = fromClass;
@@ -117,7 +140,27 @@ public class AjTypeImpl<T> implements AjType {
 	}
 	
 	public PerClause getPerClause() {
-		return null;
+		if (isAspect()) {
+			Aspect aspectAnn = clazz.getAnnotation(Aspect.class);
+			String perClause = aspectAnn.value();
+			if (perClause.equals("")) {
+				return new PerClauseImpl(PerClauseKind.SINGLETON,"");
+			} else if (perClause.startsWith("perthis(")) {
+				return new PerClauseImpl(PerClauseKind.PERTHIS,perClause.substring("perthis(".length(),perClause.length() - 1));
+			} else if (perClause.startsWith("pertarget(")) {
+				return new PerClauseImpl(PerClauseKind.PERTARGET,perClause.substring("pertarget(".length(),perClause.length() - 1));				
+			} else if (perClause.startsWith("percflow(")) {
+				return new PerClauseImpl(PerClauseKind.PERCFLOW,perClause.substring("percflow(".length(),perClause.length() - 1));								
+			} else if (perClause.startsWith("percflowbelow(")) {
+				return new PerClauseImpl(PerClauseKind.PERCFLOWBELOW,perClause.substring("percflowbelow(".length(),perClause.length() - 1));
+			} else if (perClause.startsWith("pertypewithin")) {
+				return new PerClauseImpl(PerClauseKind.PERTYPEWITHIN,perClause.substring("pertypewithin(".length(),perClause.length() - 1));				
+			} else {
+				throw new IllegalStateException("Per-clause not recognized: " + perClause);
+			}
+		} else {
+			return null;
+		}
 	}
 
 	/* (non-Javadoc)
@@ -201,106 +244,289 @@ public class AjTypeImpl<T> implements AjType {
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredField(java.lang.String)
 	 */
 	public Field getDeclaredField(String name) throws NoSuchFieldException {
-		return clazz.getDeclaredField(name);
+		Field f =  clazz.getDeclaredField(name);
+		if (f.getName().startsWith(ajcMagic)) throw new NoSuchFieldException(name);
+		return f;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredFields()
 	 */
 	public Field[] getDeclaredFields() {
-		return clazz.getDeclaredFields();
+		Field[] fields = clazz.getDeclaredFields();
+		List<Field> filteredFields = new ArrayList<Field>();
+		for (Field field : fields)
+			if (!field.getName().startsWith(ajcMagic)) filteredFields.add(field);
+		Field[] ret = new Field[filteredFields.size()];
+		filteredFields.toArray(ret);
+		return ret;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getField(java.lang.String)
 	 */
 	public Field getField(String name)  throws NoSuchFieldException {
-		return clazz.getField(name);
+		Field f =  clazz.getDeclaredField(name);
+		if (f.getName().startsWith(ajcMagic)) throw new NoSuchFieldException(name);
+		return f;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getFields()
 	 */
 	public Field[] getFields() {
-		return clazz.getFields();
+		Field[] fields = clazz.getFields();
+		List<Field> filteredFields = new ArrayList<Field>();
+		for (Field field : fields)
+			if (!field.getName().startsWith(ajcMagic)) filteredFields.add(field);
+		Field[] ret = new Field[filteredFields.size()];
+		filteredFields.toArray(ret);
+		return ret;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredMethod(java.lang.String, java.lang.Class...)
 	 */
 	public Method getDeclaredMethod(String name, Class... parameterTypes) throws NoSuchMethodException {
-		return clazz.getDeclaredMethod(name,parameterTypes);
+		Method m =  clazz.getDeclaredMethod(name,parameterTypes);
+		if (!isReallyAMethod(m)) throw new NoSuchMethodException(name);
+		return m;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getMethod(java.lang.String, java.lang.Class...)
 	 */
 	public Method getMethod(String name, Class... parameterTypes) throws NoSuchMethodException {
-		return clazz.getMethod(name,parameterTypes);
+		Method m =  clazz.getMethod(name,parameterTypes);
+		if (!isReallyAMethod(m)) throw new NoSuchMethodException(name);
+		return m;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredMethods()
 	 */
 	public Method[] getDeclaredMethods() {
-		return clazz.getDeclaredMethods();
+		Method[] methods = clazz.getDeclaredMethods();
+		List<Method> filteredMethods = new ArrayList<Method>();
+		for (Method method : methods) {
+			if (isReallyAMethod(method)) filteredMethods.add(method);
+		}
+		Method[] ret = new Method[filteredMethods.size()];
+		filteredMethods.toArray(ret);
+		return ret;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getMethods()
 	 */
 	public Method[] getMethods() {
-		return clazz.getMethods();
+		Method[] methods = clazz.getMethods();
+		List<Method> filteredMethods = new ArrayList<Method>();
+		for (Method method : methods) {
+			if (isReallyAMethod(method)) filteredMethods.add(method);
+		}
+		Method[] ret = new Method[filteredMethods.size()];
+		filteredMethods.toArray(ret);
+		return ret;
 	}
 
+	private boolean isReallyAMethod(Method method) {
+		if (method.getName().startsWith(ajcMagic)) return false;
+		if (method.isAnnotationPresent(org.aspectj.lang.annotation.Pointcut.class)) return false;
+		if (method.isAnnotationPresent(Before.class)) return false;
+		if (method.isAnnotationPresent(After.class)) return false;
+		if (method.isAnnotationPresent(AfterReturning.class)) return false;
+		if (method.isAnnotationPresent(AfterThrowing.class)) return false;
+		if (method.isAnnotationPresent(Around.class)) return false;
+		return true;
+	}
+	
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredPointcut(java.lang.String)
 	 */
-	public Pointcut getDeclaredPointcut(String name) {
-		// TODO Auto-generated method stub
-		return null;
+	public Pointcut getDeclaredPointcut(String name) throws NoSuchPointcutException {
+		Pointcut[] pcs = getDeclaredPointcuts();
+		for (Pointcut pc : pcs)
+			if (pc.getName().equals(name)) return pc;
+		throw new NoSuchPointcutException(name);
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getPointcut(java.lang.String)
 	 */
-	public Pointcut getPointcut(String name) {
-		// TODO Auto-generated method stub
-		return null;
+	public Pointcut getPointcut(String name) throws NoSuchPointcutException {
+		Pointcut[] pcs = getDeclaredPointcuts();
+		for (Pointcut pc : pcs)
+			if (pc.getName().equals(name)) return pc;
+		throw new NoSuchPointcutException(name);
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredPointcuts()
 	 */
 	public Pointcut[] getDeclaredPointcuts() {
-		// TODO Auto-generated method stub
-		return null;
+		if (declaredPointcuts != null) return declaredPointcuts;
+		List<Pointcut> pointcuts = new ArrayList<Pointcut>();
+		Method[] methods = clazz.getDeclaredMethods();
+		for (Method method : methods) {
+			Pointcut pc = asPointcut(method);
+			if (pc != null) pointcuts.add(pc);
+		}
+		Pointcut[] ret = new Pointcut[pointcuts.size()];
+		pointcuts.toArray(ret);
+		declaredPointcuts = ret;
+		return ret;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getPointcuts()
 	 */
 	public Pointcut[] getPointcuts() {
-		// TODO Auto-generated method stub
-		return null;
+		if (pointcuts != null) return pointcuts;
+		List<Pointcut> pcuts = new ArrayList<Pointcut>();
+		Method[] methods = clazz.getMethods();
+		for (Method method : methods) {
+			Pointcut pc = asPointcut(method);
+			if (pc != null) pcuts.add(pc);
+		}
+		Pointcut[] ret = new Pointcut[pcuts.size()];
+		pcuts.toArray(ret);
+		pointcuts  = ret;
+		return ret;
+	}
+
+	private Pointcut asPointcut(Method method) {
+		org.aspectj.lang.annotation.Pointcut pcAnn = method.getAnnotation(org.aspectj.lang.annotation.Pointcut.class);
+		if (pcAnn != null) {
+			String name = method.getName();
+			if (name.startsWith(ajcMagic)) {
+				// extract real name
+				int nameStart = name.indexOf("$$");
+				name = name.substring(nameStart +2,name.length());
+				int nextDollar = name.indexOf("$");
+				if (nextDollar != -1) name = name.substring(0,nextDollar);
+			}
+			return new PointcutImpl(name,pcAnn.value(),method,AjTypeSystem.getAjType(method.getDeclaringClass()));
+		} else {
+			return null;
+		}
+	}
+	
+	
+	public Advice[] getDeclaredAdvice(AdviceType... ofType) {
+		Set<AdviceType> types;
+		if (ofType.length == 0) {
+			types = EnumSet.allOf(AdviceType.class);
+		} else {
+			types = EnumSet.noneOf(AdviceType.class);
+			types.addAll(Arrays.asList(ofType));
+		}
+		return getDeclaredAdvice(types);
+	}
+	
+	public Advice[] getAdvice(AdviceType... ofType) {
+		Set<AdviceType> types;
+		if (ofType.length == 0) {
+			types = EnumSet.allOf(AdviceType.class);
+		} else {
+			types = EnumSet.noneOf(AdviceType.class);
+			types.addAll(Arrays.asList(ofType));
+		}
+		return getAdvice(types);
 	}
 
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredAdvice(org.aspectj.lang.reflect.AdviceType)
 	 */
-	public Advice[] getDeclaredAdvice(AdviceType adviceType) {
-		// TODO Auto-generated method stub
-		return null;
+	private Advice[] getDeclaredAdvice(Set ofAdviceTypes) {
+		if (declaredAdvice == null) initDeclaredAdvice();
+		List<Advice> adviceList = new ArrayList<Advice>();
+		for (Advice a : declaredAdvice) {
+			if (ofAdviceTypes.contains(a.getKind())) adviceList.add(a);
+		}
+		Advice[] ret = new Advice[adviceList.size()];
+		adviceList.toArray(ret);
+		return ret;
+	}
+
+	private void initDeclaredAdvice() {
+		Method[] methods = clazz.getDeclaredMethods();
+		List<Advice> adviceList = new ArrayList<Advice>();
+		for (Method method : methods) {
+			Advice advice = asAdvice(method);
+			if (advice != null) adviceList.add(advice);
+		}
+		declaredAdvice = new Advice[adviceList.size()];
+		adviceList.toArray(declaredAdvice);
 	}
 
 	/* (non-Javadoc)
-	 * @see org.aspectj.lang.reflect.AjType#getAdvice(org.aspectj.lang.reflect.AdviceType)
+	 * @see org.aspectj.lang.reflect.AjType#getDeclaredAdvice(org.aspectj.lang.reflect.AdviceType)
 	 */
-	public Advice[] getAdvice(AdviceType adviceType) {
-		// TODO Auto-generated method stub
-		return null;
+	private Advice[] getAdvice(Set ofAdviceTypes) {
+		if (advice == null) initAdvice();
+		List<Advice> adviceList = new ArrayList<Advice>();
+		for (Advice a : advice) {
+			if (ofAdviceTypes.contains(a.getKind())) adviceList.add(a);
+		}
+		Advice[] ret = new Advice[adviceList.size()];
+		adviceList.toArray(ret);
+		return ret;
 	}
 
+	private void initAdvice() {
+		Method[] methods = clazz.getDeclaredMethods();
+		List<Advice> adviceList = new ArrayList<Advice>();
+		for (Method method : methods) {
+			Advice advice = asAdvice(method);
+			if (advice != null) adviceList.add(advice);
+		}
+		advice = new Advice[adviceList.size()];
+		adviceList.toArray(advice);
+	}
+
+
+	public Advice getAdvice(String name) throws NoSuchAdviceException {
+		if (name.equals("")) throw new IllegalArgumentException("use getAdvice(AdviceType...) instead for un-named advice");
+		if (advice == null) initAdvice();
+		for (Advice a : advice) {
+			if (a.getName().equals(name)) return a;
+		}
+		throw new NoSuchAdviceException(name);
+	}
+	
+	public Advice getDeclaredAdvice(String name) throws NoSuchAdviceException {
+		if (name.equals("")) throw new IllegalArgumentException("use getAdvice(AdviceType...) instead for un-named advice");
+		if (declaredAdvice == null) initDeclaredAdvice();
+		for (Advice a : declaredAdvice) {
+			if (a.getName().equals(name)) return a;
+		}
+		throw new NoSuchAdviceException(name);
+	}
+	
+	private Advice asAdvice(Method method) {
+		if (method.getAnnotations().length == 0) return null;
+		Before beforeAnn = method.getAnnotation(Before.class);
+		if (beforeAnn != null) return new AdviceImpl(method,beforeAnn.value(),AdviceType.BEFORE);
+		After afterAnn = method.getAnnotation(After.class);
+		if (afterAnn != null) return new AdviceImpl(method,afterAnn.value(),AdviceType.AFTER);
+		AfterReturning afterReturningAnn = method.getAnnotation(AfterReturning.class);
+		if (afterReturningAnn != null) {
+			String pcExpr = afterReturningAnn.pointcut();
+			if (pcExpr.equals("")) pcExpr = afterReturningAnn.value();
+			return new AdviceImpl(method,pcExpr,AdviceType.AFTER_RETURNING);
+		}
+		AfterThrowing afterThrowingAnn = method.getAnnotation(AfterThrowing.class);
+		if (afterThrowingAnn != null) {
+			String pcExpr = afterThrowingAnn.pointcut();
+			if (pcExpr == null) pcExpr = afterThrowingAnn.value();
+			return new AdviceImpl(method,pcExpr,AdviceType.AFTER_THROWING);
+		}
+		Around aroundAnn = method.getAnnotation(Around.class);
+		if (aroundAnn != null) return new AdviceImpl(method,aroundAnn.value(),AdviceType.AROUND);
+		return null;
+	}
+	
 	/* (non-Javadoc)
 	 * @see org.aspectj.lang.reflect.AjType#getDeclaredITDMethod(java.lang.String, java.lang.Class, java.lang.Class...)
 	 */
@@ -509,12 +735,7 @@ public class AjTypeImpl<T> implements AjType {
 	 * @see org.aspectj.lang.reflect.AjType#isAspect()
 	 */
 	public boolean isAspect() {
-		// 2 tests we could use today... presence of aspectOf method (but what if user defines one in 
-		// a class), and presence of @Aspect annotation (@AspectJ style only). 
-		// Is the solution to put the @Aspect annotation on a code-style aspect too during weaving?
-		// Or should we generate some private structure with all the reflection info in it, including the aspect
-		// info?
-		return false;
+		return clazz.getAnnotation(Aspect.class) != null;
 	}
 
 	/* (non-Javadoc)
@@ -524,4 +745,20 @@ public class AjTypeImpl<T> implements AjType {
 		return clazz.isMemberClass() && isAspect();
 	}
 
+	public boolean isPrivileged() {
+		return isAspect() && clazz.isAnnotationPresent(ajcPrivileged.class);
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (!(obj instanceof AjTypeImpl)) return false;
+		AjTypeImpl other = (AjTypeImpl) obj;
+		return other.clazz.equals(clazz);
+	}
+	
+	@Override
+	public int hashCode() {
+		return clazz.hashCode();
+	}
+
 }

aspectj5rt/java5-src/org/aspectj/internal/lang/reflect/PerClauseImpl.java

@@ -0,0 +1,45 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+
+import org.aspectj.lang.reflect.PerClause;
+import org.aspectj.lang.reflect.PerClauseKind;
+
+/**
+ * @author colyer
+ *
+ */
+public class PerClauseImpl implements PerClause {
+
+	private final PerClauseKind kind;
+	private final String pointcutExpression;
+	
+	protected PerClauseImpl(PerClauseKind kind, String pointcutExpression) {
+		this.kind = kind;
+		this.pointcutExpression = pointcutExpression;
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.aspectj.lang.reflect.PerClause#getKind()
+	 */
+	public PerClauseKind getKind() {
+		return kind;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.aspectj.lang.reflect.PerClause#getPointcutExpression()
+	 */
+	public String getPointcutExpression() {
+		return pointcutExpression;
+	}
+
+}

aspectj5rt/java5-src/org/aspectj/internal/lang/reflect/PointcutImpl.java

@@ -0,0 +1,60 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+
+import java.lang.reflect.Method;
+
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.Pointcut;
+
+/**
+ * @author colyer
+ *
+ */
+public class PointcutImpl implements Pointcut {
+
+	private final String name;
+	private final String pc;
+	private final Method baseMethod;
+	private final AjType declaringType;
+	
+	protected PointcutImpl(String name, String pc, Method method, AjType declaringType) {
+		this.name = name;
+		this.pc = pc;
+		this.baseMethod = method;
+		this.declaringType = declaringType;
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.aspectj.lang.reflect.Pointcut#getPointcutExpression()
+	 */
+	public String getPointcutExpression() {
+		return pc;
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+	public int getModifiers() {
+		return baseMethod.getModifiers();
+	}
+
+	public Class<?>[] getParameterTypes() {
+		return baseMethod.getParameterTypes();
+	}
+
+	public AjType getDeclaringType() {
+		return declaringType;
+	}
+
+}

aspectj5rt/java5-src/org/aspectj/lang/annotation/AdviceName.java

@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *   Adrian Colyer									initial implementation
+ *******************************************************************************/
+package org.aspectj.lang.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+/**
+ * Used to annotated code-style advice to name it
+ * Name is used by reflection api if present, may in future be used in adviceexecution() pcd.
+ * It is an error to use the @AdviceName annotation on an annotation-style advice declaration.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface AdviceName {
+
+    /**
+     * The name of the advice
+     */
+    String value();
+}

aspectj5rt/java5-src/org/aspectj/lang/reflect/Advice.java

@@ -13,4 +13,9 @@ package org.aspectj.lang.reflect;
 
 public interface Advice {
 
+	AdviceType getKind();
+	
+	String getName();
+	
+	String getPointcutExpression();
 }

aspectj5rt/java5-src/org/aspectj/lang/reflect/AjType.java

@@ -11,12 +11,13 @@
  * ******************************************************************/
 package org.aspectj.lang.reflect;
 
-import java.lang.reflect.Method;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
-import java.lang.annotation.Annotation;
+import java.util.Set;
 
 /**
  * The runtime representation of a type (Aspect, Class, Interface, Annotation, Enum, or Array) in an AspectJ
@@ -96,9 +97,9 @@ public interface AjType<T> extends Type {
 	
 	// pointcuts
 	
-	public Pointcut getDeclaredPointcut(String name);
+	public Pointcut getDeclaredPointcut(String name) throws NoSuchPointcutException;
 	
-	public Pointcut getPointcut(String name);
+	public Pointcut getPointcut(String name) throws NoSuchPointcutException;
 	
 	public Pointcut[] getDeclaredPointcuts();
 	
@@ -106,9 +107,13 @@ public interface AjType<T> extends Type {
 	
 	// advice
 	
-	public Advice[] getDeclaredAdvice(AdviceType adviceType);
+	public Advice[] getDeclaredAdvice(AdviceType... ofTypes);
+	
+	public Advice[] getAdvice(AdviceType... ofTypes);
+	
+	public Advice getAdvice(String name) throws NoSuchAdviceException;
 	
-	public Advice[] getAdvice(AdviceType adviceType);
+	public Advice getDeclaredAdvice(String name) throws NoSuchAdviceException;
 		
 	// inter-type declarations
 	
@@ -172,16 +177,6 @@ public interface AjType<T> extends Type {
 	
 	public boolean isMemberAspect();
 	
+	public boolean isPrivileged();
+	
 }
-
-
-// implementation notes:
-
-// additional runtime info we need:
-// whether or not a class is an aspect
-// pointcuts in a type (+ name, parameter types, parameter names, expression)
-// itds in a type (is there enough in the class file already?)
-// advice in a type (should be enough in the class file already?)
-// declares in an aspect (+ associated info)
-
-// anchor in a generated static member on the type: ajc$reflectionInfo ? or use annotations??

aspectj5rt/java5-src/org/aspectj/lang/reflect/AjTypeSystem.java

@@ -11,6 +11,8 @@
  * ******************************************************************/
 package org.aspectj.lang.reflect;
 
+import org.aspectj.internal.lang.reflect.AjTypeImpl;
+
 /**
  * @author colyer
  *
@@ -18,6 +20,6 @@ package org.aspectj.lang.reflect;
 public class AjTypeSystem {
 
 		public static AjType getAjType(Class fromClass) {
-			return null;
+			return new AjTypeImpl(fromClass);
 		}
 }

aspectj5rt/java5-src/org/aspectj/lang/reflect/NoSuchAdviceException.java

@@ -0,0 +1,31 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.lang.reflect;
+
+/**
+ * @author colyer
+ *
+ */
+public class NoSuchAdviceException extends Exception {
+
+	private static final long serialVersionUID = 3256444698657634352L;
+	private String name;
+	
+	public NoSuchAdviceException(String name) {
+		this.name = name;
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+}

aspectj5rt/java5-src/org/aspectj/lang/reflect/NoSuchPointcutException.java

@@ -0,0 +1,31 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.lang.reflect;
+
+/**
+ * @author colyer
+ *
+ */
+public class NoSuchPointcutException extends Exception {
+
+	private static final long serialVersionUID = 3256444698657634352L;
+	private String name;
+	
+	public NoSuchPointcutException(String name) {
+		this.name = name;
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+}

aspectj5rt/java5-src/org/aspectj/lang/reflect/PerClause.java

@@ -16,5 +16,6 @@ package org.aspectj.lang.reflect;
  *
  */
 public interface PerClause {
-
+	PerClauseKind getKind();
+	String getPointcutExpression();
 }

aspectj5rt/java5-src/org/aspectj/lang/reflect/PerClauseKind.java

@@ -0,0 +1,25 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.lang.reflect;
+
+/**
+ * @author colyer
+ * The different perclauses (aspect instantiation models)
+ */
+public enum PerClauseKind {
+	SINGLETON,
+	PERTHIS,
+	PERTARGET,
+	PERCFLOW,
+	PERCFLOWBELOW,
+	PERTYPEWITHIN;
+}

aspectj5rt/java5-src/org/aspectj/lang/reflect/Pointcut.java

@@ -13,4 +13,13 @@ package org.aspectj.lang.reflect;
 
 public interface Pointcut {
 
+	String getPointcutExpression();
+	
+	String getName();
+	
+	int getModifiers();
+	
+	Class<?>[] getParameterTypes();
+	
+	AjType getDeclaringType();
 }

aspectj5rt/testsrc/Aspectj5rtModuleTests.java

@@ -12,12 +12,19 @@
 
 // default package
 
-import junit.framework.*;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.aspectj.internal.lang.reflect.AjTypeTests;
+import org.aspectj.internal.lang.reflect.AjTypeTestsWithAspects;
 
 public class Aspectj5rtModuleTests extends TestCase {
 
     public static Test suite() { 
         TestSuite suite = new TestSuite("Aspectj5rt module tests");
+		suite.addTestSuite(AjTypeTests.class);
+		suite.addTestSuite(AjTypeTestsWithAspects.class);
         return suite;
     }
 

aspectj5rt/testsrc/org/aspectj/internal/lang/reflect/AjTypeTests.java

@@ -0,0 +1,304 @@
+package org.aspectj.internal.lang.reflect;
+
+import java.io.Serializable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import junit.framework.TestCase;
+
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+
+public class AjTypeTests extends TestCase {
+
+	private AjType stringType;
+	
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		stringType = AjTypeSystem.getAjType(String.class);
+	}
+	
+	public void testCreateAjType() {
+		assertNotNull("should find type",stringType);
+	}
+	
+	public void testGetName() {
+		assertEquals(String.class.getName(),stringType.getName());
+	}
+	
+	public void testGetPackage() {
+		assertEquals(String.class.getPackage(),stringType.getPackage());
+	}
+	
+	public void testGetInterfaces() {
+		Class[] i1 = String.class.getInterfaces();
+		Class[] i2 = stringType.getInterfaces();
+		assertEquals(i1.length,i2.length);
+		for (int i = 0; i < i1.length; i++)
+			assertEquals(i1[i],i2[i]);
+	}
+	
+	public void testGetModifiers() {
+		assertEquals(String.class.getModifiers(),stringType.getModifiers());
+	}
+	
+	public void testGetSupertype() {
+		Class stringSuper = String.class.getSuperclass();
+		AjType ajSuper = stringType.getSupertype();
+		assertEquals(AjTypeSystem.getAjType(stringSuper),ajSuper);
+	}
+
+	public void testGetGenericSupertype() {
+		Type t  = AjTypeSystem.getAjType(Goo.class).getGenericSupertype();
+		assertEquals(Foo.class,t);
+	}
+	
+	public void testGetEnclosingMethod() {
+		new Goo().foo();
+	}
+
+	public void testGetEnclosingConstructor() {
+		new Goo();
+	}
+
+	public void testGetEnclosingType() {
+		AjType t = AjTypeSystem.getAjType(Foo.Z.class);
+		assertEquals("org.aspectj.internal.lang.reflect.Foo",t.getEnclosingType().getName());
+	}
+	
+	public void testGetDeclaringType() {
+		AjType t = AjTypeSystem.getAjType(Foo.Z.class);
+		assertEquals("org.aspectj.internal.lang.reflect.Foo",t.getDeclaringType().getName());
+	}
+	
+	public void testIsAnnotationPresent() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		assertTrue(foo.isAnnotationPresent(SomeAnn.class));
+		assertFalse(goo.isAnnotationPresent(SomeAnn.class));
+	}
+	
+	public void testGetAnnotation() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		assertNotNull(foo.getAnnotation(SomeAnn.class));
+		assertNull(goo.getAnnotation(SomeAnn.class));
+	}
+
+	public void testGetAnnotations() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		assertEquals(1,foo.getAnnotations().length);
+		assertEquals(0,goo.getAnnotations().length);
+	}
+
+	public void testGetDeclaredAnnotations() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		assertEquals(0,goo.getDeclaredAnnotations().length);
+		assertEquals(1,foo.getDeclaredAnnotations().length);
+	}
+	
+	public void testGetAjTypes() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType[] fooTypes = foo.getAjTypes();
+		assertEquals(1,fooTypes.length);
+		assertEquals("org.aspectj.internal.lang.reflect.Foo$Z",fooTypes[0].getName());
+	}
+	
+	public void testGetDeclaredAjTypes() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		AjType[] fooTypes = foo.getDeclaredAjTypes();
+		assertEquals(2,fooTypes.length);
+		assertEquals("org.aspectj.internal.lang.reflect.Foo$Z",fooTypes[0].getName());
+		assertEquals("org.aspectj.internal.lang.reflect.Foo$XX",fooTypes[1].getName());
+	}
+	
+	public void testGetConstructor() throws Exception {
+		Constructor c1 = String.class.getConstructor(String.class);
+		Constructor c2 = stringType.getConstructor(String.class);
+		assertEquals(c1,c2);
+	}
+	
+	public void testGetConstructors() {
+		Constructor[] c1 = String.class.getConstructors();
+		Constructor[] c2 = stringType.getConstructors();
+		assertEquals(c1.length,c2.length);
+		for (int i = 0; i < c1.length; i++)
+			assertEquals(c1[i],c2[i]);
+	}
+	
+	public void testGetDeclaredConstructor() throws Exception {
+		Constructor c1 = String.class.getDeclaredConstructor(String.class);
+		Constructor c2 = stringType.getDeclaredConstructor(String.class);
+		assertEquals(c1,c2);
+	}
+	
+	public void testGetDeclaredConstructors() {
+		Constructor[] c1 = String.class.getDeclaredConstructors();
+		Constructor[] c2 = stringType.getDeclaredConstructors();
+		assertEquals(c1.length,c2.length);
+		for (int i = 0; i < c1.length; i++)
+			assertEquals(c1[i],c2[i]);
+	}
+	
+	public void testGetDeclaredField() throws Exception {
+		Field f1 = String.class.getDeclaredField("value");
+		Field f2 = stringType.getDeclaredField("value");
+		assertEquals(f1,f2);
+	}
+	
+	public void testGetDeclaredFields() {
+		Field[] f1 = String.class.getDeclaredFields();
+		Field[] f2 = stringType.getDeclaredFields();
+		assertEquals(f1.length,f2.length);
+		for (int i = 0; i < f1.length; i++)
+			assertEquals(f1[i],f2[i]);
+	}
+	
+	public void testGetField() throws Exception {
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		assertEquals("g",goo.getField("g").getName());
+	}
+	
+	public void testGetFields() {
+		AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+		Field[] fields = goo.getFields();
+		assertEquals(1,fields.length);
+		assertEquals("g",fields[0].getName());
+		
+	}
+	
+	public void testGetDeclaredMethod() throws Exception {
+		Method m1 = String.class.getDeclaredMethod("toUpperCase");
+		Method m2 = stringType.getDeclaredMethod("toUpperCase");
+		assertEquals(m1,m2);
+	}
+	
+	public void testGetMethod() throws Exception {
+		Method m1 = String.class.getMethod("toUpperCase");
+		Method m2 = stringType.getMethod("toUpperCase");
+		assertEquals(m1,m2);		
+	}
+	
+	public void testGetDeclaredMethods() {
+		Method[] m1 = String.class.getDeclaredMethods();
+		Method[] m2 = stringType.getDeclaredMethods();
+		assertEquals(m1.length,m2.length);
+		for (int i = 0; i < m1.length; i++)
+			assertEquals(m1[i],m2[i]);
+	}
+
+	public void testGetMethods() {
+		Method[] m1 = String.class.getMethods();
+		Method[] m2 = stringType.getMethods();
+		assertEquals(m1.length,m2.length);
+		for (int i = 0; i < m1.length; i++)
+			assertEquals(m1[i],m2[i]);
+	}
+	
+	public void testGetEnumConstants() {
+		AjType e = AjTypeSystem.getAjType(E.class);
+		Object[] consts = e.getEnumConstants();
+		assertEquals(3,consts.length);
+	}
+	
+	public void testGetTypeParameters() {
+		AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+		TypeVariable<Class<Foo>>[] tvs = foo.getTypeParameters();
+		assertEquals(1,tvs.length);
+		assertEquals("T",tvs[0].getName());
+	}
+	
+	public void testIsEnum() {
+		assertFalse(stringType.isEnum());
+	}
+	
+	public void testIsInstance() {
+		assertTrue(stringType.isInstance("I am"));
+	}
+	
+	public void testIsInterface() {
+		assertFalse(stringType.isInterface());
+		assertTrue(AjTypeSystem.getAjType(Serializable.class).isInterface());
+	}
+	
+	public void testIsLocalClass() {
+		assertFalse(stringType.isLocalClass());
+	}
+	
+	public void testIsArray() {
+		assertFalse(stringType.isArray());
+		assertTrue(AjTypeSystem.getAjType(Integer[].class).isArray());
+	}
+	
+	public void testIsPrimitive() {
+		assertFalse(stringType.isPrimitive());
+		assertTrue(AjTypeSystem.getAjType(boolean.class).isPrimitive());
+	}
+	
+	public void testIsAspect() {
+		assertFalse(stringType.isAspect());
+	}
+	
+	public void testIsMemberAspect() {
+		assertFalse(stringType.isMemberAspect());
+	}
+	
+	public void testIsPrivileged() {
+		assertFalse(stringType.isPrivileged());
+	}
+	
+	public void testEquals() {
+		AjType stringTypeTwo = AjTypeSystem.getAjType(String.class);
+		assertTrue(stringType.equals(stringTypeTwo));
+	}
+	
+	public void testHashCode() {
+		AjType stringTypeTwo = AjTypeSystem.getAjType(String.class);
+		assertEquals(stringType.hashCode(),stringTypeTwo.hashCode());		
+	}
+
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface SomeAnn {}
+
+@SomeAnn
+class Foo<T> {
+	
+	public Foo() {
+		class Y { int y; }
+		AjType t = AjTypeSystem.getAjType(Y.class);
+		Constructor c = t.getEnclosingConstructor();
+		if (!c.getName().equals("org.aspectj.internal.lang.reflect.Foo")) throw new RuntimeException("should have been Foo");
+	}
+	public void foo() {
+		class X { int x; }
+		AjType t = AjTypeSystem.getAjType(X.class);
+		Method m = t.getEnclosingMethod();
+		if (!m.getName().equals("foo")) throw new RuntimeException("should have been foo");
+	}
+	public class Z { int z; }
+	class XX { int xx; }
+}
+
+class Goo extends Foo {
+  @interface IX {}	
+  
+  public Goo() {
+	  super();
+  }
+
+  public int g;
+  int g2;
+
+}
+
+enum E { A,B,C; }

aspectj5rt/testsrc/org/aspectj/internal/lang/reflect/AjTypeTestsWithAspects.java

@@ -0,0 +1,371 @@
+package org.aspectj.internal.lang.reflect;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.EnumSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.aspectj.internal.lang.annotation.ajcPrivileged;
+import org.aspectj.lang.annotation.AdviceName;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.reflect.Advice;
+import org.aspectj.lang.reflect.AdviceType;
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+import org.aspectj.lang.reflect.NoSuchAdviceException;
+import org.aspectj.lang.reflect.NoSuchPointcutException;
+import org.aspectj.lang.reflect.PerClause;
+import org.aspectj.lang.reflect.PerClauseKind;
+import org.aspectj.lang.reflect.Pointcut;
+
+public class AjTypeTestsWithAspects extends TestCase {
+
+	private AjType sa;
+	
+	protected void setUp() throws Exception {
+		super.setUp();
+		sa = AjTypeSystem.getAjType(SimpleAspect.class);
+	}
+
+	public void testGetPerClause() {
+		AjType perThisA = AjTypeSystem.getAjType(PerThisAspect.class);
+		AjType perTargetA = AjTypeSystem.getAjType(PerTargetAspect.class);
+		AjType perCflowA = AjTypeSystem.getAjType(PerCflowAspect.class);
+		AjType perCflowbelowA = AjTypeSystem.getAjType(PerCflowbelowAspect.class);
+		AjType perTypeWithinA = AjTypeSystem.getAjType(PerTypeWithin.class);
+		
+		PerClause pc = perThisA.getPerClause();
+		assertEquals(PerClauseKind.PERTHIS,pc.getKind());
+		assertEquals("pc()",pc.getPointcutExpression());
+		
+		pc= perTargetA.getPerClause();
+		assertEquals(PerClauseKind.PERTARGET,pc.getKind());
+		assertEquals("pc()",pc.getPointcutExpression());
+
+		pc= perCflowA.getPerClause();
+		assertEquals(PerClauseKind.PERCFLOW,pc.getKind());
+		assertEquals("pc()",pc.getPointcutExpression());
+
+		pc= perCflowbelowA.getPerClause();
+		assertEquals(PerClauseKind.PERCFLOWBELOW,pc.getKind());
+		assertEquals("pc()",pc.getPointcutExpression());
+
+		pc= perTypeWithinA.getPerClause();
+		assertEquals(PerClauseKind.PERTYPEWITHIN,pc.getKind());
+		assertEquals("org.aspectj..*",pc.getPointcutExpression());
+
+	}
+	
+	public void testGetDeclaredField() throws Exception{
+		Field f = sa.getDeclaredField("s");
+		try {
+			Field f2 = sa.getDeclaredField("ajc$xyz$s");
+			fail("Expecting NoSuchFieldException");
+		} catch (NoSuchFieldException nsf) {}
+	}
+	
+	public void testGetField() throws Exception {
+		Field f = sa.getField("s");
+		try {
+			Field f2 = sa.getField("ajc$xyz$s");
+			fail("Expecting NoSuchFieldException");
+		} catch (NoSuchFieldException nsf) {}		
+	}
+	
+	public void testGetDeclaredFields() {
+		Field[] fields = sa.getDeclaredFields();
+		assertEquals(1,fields.length);
+		assertEquals("s",fields[0].getName());
+	}
+
+	public void testGetFields() {
+		Field[] fields = sa.getFields();
+		assertEquals(1,fields.length);
+		assertEquals("s",fields[0].getName());
+	}
+	
+	public void testGetDeclaredMethod() throws Exception {
+		Method m = sa.getDeclaredMethod("aMethod");
+		try {
+			Method m2 = sa.getDeclaredMethod("logEntry");
+			fail("Expecting NoSuchMethodException");
+		} catch(NoSuchMethodException ex) {}
+		try {
+			Method m3 = sa.getDeclaredMethod("ajc$before$123");
+			fail("Expecting NoSuchMethodException");
+		} catch(NoSuchMethodException ex) {}
+	}
+	
+	public void testGetMethod() throws Exception {
+		Method m = sa.getMethod("aMethod");
+		try {
+			Method m2 = sa.getMethod("logEntry");
+			fail("Expecting NoSuchMethodException");
+		} catch(NoSuchMethodException ex) {}
+		try {
+			Method m3 = sa.getMethod("ajc$before$123");
+			fail("Expecting NoSuchMethodException");
+		} catch(NoSuchMethodException ex) {}		
+	}
+
+	public void testGetDeclaredMethods() {
+		Method[] ms = sa.getDeclaredMethods();
+		assertEquals(1,ms.length);
+		assertEquals("aMethod",ms[0].getName());
+	}
+
+	public void testGetMethods() {
+		Method[] ms = sa.getMethods();
+		assertEquals(10,ms.length);
+		assertEquals("aMethod",ms[0].getName());
+	}
+	
+	public void testGetDeclaredPointcut() throws Exception {
+		Pointcut p1 = sa.getDeclaredPointcut("simpleAspectMethodExecution");
+		assertEquals("simpleAspectMethodExecution",p1.getName());
+		assertEquals("execution(* SimpleAspect.*(..))",p1.getPointcutExpression());
+		assertEquals(sa,p1.getDeclaringType());
+		assertEquals(0,p1.getParameterTypes().length);
+		assertTrue(Modifier.isPublic(p1.getModifiers()));
+		Pointcut p2 = sa.getDeclaredPointcut("simpleAspectCall");
+		assertEquals("simpleAspectCall",p2.getName());
+		assertEquals("call(* SimpleAspect.*(..))",p2.getPointcutExpression());
+		assertEquals(sa,p2.getDeclaringType());
+		assertEquals(1,p2.getParameterTypes().length);
+		assertTrue(Modifier.isPrivate(p2.getModifiers()));
+		try {
+			Pointcut p3 = sa.getDeclaredPointcut("sausages");
+			fail("Expecting NoSuchPointcutExcetpion");
+		} catch (NoSuchPointcutException ex) { 
+			assertEquals("sausages",ex.getName());
+		}		
+	}
+	
+	public void testGetPointcut() throws Exception {
+		Pointcut p1 = sa.getPointcut("simpleAspectMethodExecution");
+		assertEquals("simpleAspectMethodExecution",p1.getName());
+		assertEquals("execution(* SimpleAspect.*(..))",p1.getPointcutExpression());
+		assertEquals(sa,p1.getDeclaringType());
+		assertEquals(0,p1.getParameterTypes().length);
+		assertTrue(Modifier.isPublic(p1.getModifiers()));
+		Pointcut p2 = sa.getPointcut("simpleAspectCall");
+		assertEquals("simpleAspectCall",p2.getName());
+		assertEquals("call(* SimpleAspect.*(..))",p2.getPointcutExpression());
+		assertEquals(sa,p2.getDeclaringType());
+		assertEquals(1,p2.getParameterTypes().length);
+		assertTrue(Modifier.isPrivate(p2.getModifiers()));
+		try {
+			Pointcut p3 = sa.getPointcut("sausages");
+			fail("Expecting NoSuchPointcutExcetpion");
+		} catch (NoSuchPointcutException ex) { 
+			assertEquals("sausages",ex.getName());
+		}		
+	}
+	
+	public void testGetDeclaredPointcuts() {
+		Pointcut[] pcs = sa.getDeclaredPointcuts();
+		assertEquals(2,pcs.length);
+		assertEquals("simpleAspectMethodExecution",pcs[0].getName());
+		assertEquals("simpleAspectCall",pcs[1].getName());
+	}
+	
+	public void testGetPointcuts() {
+		Pointcut[] pcs = sa.getPointcuts();
+		assertEquals(1,pcs.length);
+		assertEquals("simpleAspectMethodExecution",pcs[0].getName());
+	}
+	
+	public void testGetDeclaredAdvice() {
+		Advice[] advice = sa.getDeclaredAdvice();
+		assertEquals(10,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.BEFORE);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER_RETURNING);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER_THROWING);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AROUND);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.BEFORE,AdviceType.AFTER);
+		assertEquals(4,advice.length);
+
+		advice = sa.getDeclaredAdvice(AdviceType.BEFORE);
+		assertEquals("execution(* SimpleAspect.*(..))",advice[0].getPointcutExpression());
+		assertEquals("logEntry",advice[0].getName());
+		assertEquals(AdviceType.BEFORE,advice[0].getKind());
+		assertEquals("execution(* SimpleAspect.*(..))",advice[1].getPointcutExpression());
+		assertEquals("",advice[1].getName());
+	}
+	
+	public void testGetAdvice() {
+		Advice[] advice = sa.getDeclaredAdvice();
+		assertEquals(10,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.BEFORE);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER_RETURNING);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AFTER_THROWING);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.AROUND);
+		assertEquals(2,advice.length);
+		advice = sa.getDeclaredAdvice(AdviceType.BEFORE,AdviceType.AFTER);
+		assertEquals(4,advice.length);		
+	}
+	
+	public void testGetNamedAdvice() throws Exception {
+		Advice a = sa.getAdvice("logItAll");
+		assertEquals("logItAll",a.getName());
+		assertEquals(AdviceType.AROUND,a.getKind());
+		a = sa.getAdvice("whatGoesAround");
+		assertEquals("whatGoesAround",a.getName());
+		assertEquals(AdviceType.AROUND,a.getKind());
+		try {
+			a = sa.getAdvice("ajc$after$123");
+			fail("Expecting NoSuchAdviceException");
+		} catch (NoSuchAdviceException ex) {
+			assertEquals("ajc$after$123",ex.getName());
+		}
+		try {
+			a = sa.getAdvice("");
+			fail("Expecting IllegalArgumentException");
+		} catch (IllegalArgumentException ex) {
+			;
+		}
+	}
+	
+	public void testGetNamedDeclaredAdvice() throws Exception {
+		Advice a = sa.getDeclaredAdvice("logItAll");
+		assertEquals("logItAll",a.getName());
+		assertEquals(AdviceType.AROUND,a.getKind());
+		a = sa.getDeclaredAdvice("whatGoesAround");
+		assertEquals("whatGoesAround",a.getName());
+		assertEquals(AdviceType.AROUND,a.getKind());
+		try {
+			a = sa.getDeclaredAdvice("ajc$after$123");
+			fail("Expecting NoSuchAdviceException");
+		} catch (NoSuchAdviceException ex) {
+			assertEquals("ajc$after$123",ex.getName());
+		}
+		try {
+			a = sa.getDeclaredAdvice("");
+			fail("Expecting IllegalArgumentException");
+		} catch (IllegalArgumentException ex) {
+			;
+		}
+	}
+	
+	public void testIsPrivileged() {
+		assertFalse(sa.isPrivileged());
+		assertTrue(AjTypeSystem.getAjType(SimplePrivilegedAspect.class).isPrivileged());		
+	}
+	
+	public void testIsAspect() {
+		assertTrue(sa.isAspect());
+	}
+	
+	public void testIsMemberAspect() {
+		assertFalse(AjTypeSystem.getAjType(SimplePrivilegedAspect.class).isMemberAspect());
+		assertTrue(AjTypeSystem.getAjType(SimplePrivilegedAspect.MemberAspect.class).isMemberAspect());
+
+	}
+}
+
+
+@Aspect 
+class SimpleAspect {
+	
+  // regular field
+  public String s;
+  
+  // synthetic field
+  public String ajc$xyz$s;
+  
+  // regular method
+  public void aMethod() {}
+  
+  // advice method, annotation style
+  @Before("execution(* SimpleAspect.*(..))")
+  public void logEntry() {}
+	
+  // advice method, code style
+  @Before("execution(* SimpleAspect.*(..))")
+  public void ajc$before$123() {}
+
+  // advice method, annotation style
+  @After("execution(* SimpleAspect.*(..))")
+  public void logFinally() {}
+	
+  // advice method, code style
+  @After("execution(* SimpleAspect.*(..))")
+  public void ajc$after$123() {}
+
+  // advice method, annotation style
+  @AfterReturning("execution(* SimpleAspect.*(..))")
+  public void logExit() {}
+	
+  // advice method, code style
+  @AfterReturning("execution(* SimpleAspect.*(..))")
+  public void ajc$afterReturning$123() {}
+
+  // advice method, annotation style
+  @AfterThrowing("execution(* SimpleAspect.*(..))")
+  public void logException() {}
+	
+  // advice method, code style
+  @AfterThrowing("execution(* SimpleAspect.*(..))")
+  public void ajc$afterThrowing$123() {}
+
+  // advice method, annotation style
+  @Around("execution(* SimpleAspect.*(..))")
+  public void logItAll() {}
+	
+  // advice method, code style
+  @Around("execution(* SimpleAspect.*(..))")
+  @AdviceName("whatGoesAround")
+  public void ajc$around$123() {}
+
+  // pointcut, annotation style
+  @org.aspectj.lang.annotation.Pointcut("execution(* SimpleAspect.*(..))")
+  public void simpleAspectMethodExecution() {};
+  
+  // pointcut, code style
+  @org.aspectj.lang.annotation.Pointcut("call(* SimpleAspect.*(..))")
+  private void ajc$pointcut$$simpleAspectCall$123(SimpleAspect target) {};
+  
+}
+
+@Aspect
+@ajcPrivileged
+class SimplePrivilegedAspect {
+	
+	@Aspect
+	static class MemberAspect {}
+	
+}
+
+@Aspect("perthis(pc())")
+class PerThisAspect {}
+
+@Aspect("pertarget(pc())")
+class PerTargetAspect {}
+
+@Aspect("percflow(pc())")
+class PerCflowAspect {}
+
+@Aspect("percflowbelow(pc())")
+class PerCflowbelowAspect {}
+
+@Aspect("pertypewithin(org.aspectj..*)") 
+class PerTypeWithin {}