finally fixed 75442+78383, impl a visitor pattern in patterns package, turned on LTWperClause tests (clean up will follow, just want this visitor in for now)

43 files changed, 1277 insertions, 23 deletions

diff --git a/weaver/src/org/aspectj/weaver/PerObjectInterfaceTypeMunger.java b/weaver/src/org/aspectj/weaver/PerObjectInterfaceTypeMunger.java
index 512f9ca4f..99ce3bd50 100644
--- a/weaver/src/org/aspectj/weaver/PerObjectInterfaceTypeMunger.java
+++ b/weaver/src/org/aspectj/weaver/PerObjectInterfaceTypeMunger.java
@@ -25,6 +25,12 @@ import java.util.HashMap;
 import org.aspectj.weaver.patterns.Pointcut;
 import org.aspectj.weaver.patterns.FastMatchInfo;
 import org.aspectj.weaver.patterns.PerClause;
+import org.aspectj.weaver.patterns.PointcutVisitor;
+import org.aspectj.weaver.patterns.PatternNode;
+import org.aspectj.weaver.patterns.PerThisOrTargetPointcutVisitor;
+import org.aspectj.weaver.patterns.PerObject;
+import org.aspectj.weaver.patterns.TypePattern;
+import org.aspectj.weaver.patterns.PerFromSuper;
 import org.aspectj.util.FuzzyBoolean;
 
 public class PerObjectInterfaceTypeMunger extends ResolvedTypeMunger {
@@ -86,9 +92,28 @@ public class PerObjectInterfaceTypeMunger extends ResolvedTypeMunger {
 	}
 	
 	public boolean matches(ResolvedTypeX matchType, ResolvedTypeX aspectType) {
+        if (matchType.isInterface()) return false;
+
+        //FIXME AV - cache that
+        final boolean isPerThis;
+        if (aspectType.getPerClause() instanceof PerFromSuper) {
+            PerFromSuper ps = (PerFromSuper) aspectType.getPerClause();
+            isPerThis = ((PerObject)ps.lookupConcretePerClause(aspectType)).isThis();
+        } else {
+            isPerThis = ((PerObject)aspectType.getPerClause()).isThis();
+        }
+        PerThisOrTargetPointcutVisitor v = new PerThisOrTargetPointcutVisitor(
+                !isPerThis,
+                aspectType
+        );
+        TypePattern tp = v.getPerTypePointcut(testPointcut);
+
+        if (true) return tp.matchesStatically(matchType);
+
+
         //FIXME ATAJ waiting Andy patch...
         // comment from Andy - this is hard to fix...
-        
+
         // right now I filter @AJ aspect else it end up with duplicate members
         //return !matchType.isInterface() && !matchType.isAnnotationStyleAspect();
         Set aspects = (Set)s_advisedTypeToAspects.get(matchType);
diff --git a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
index 164047189..5de34cf38 100644
--- a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
+++ b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
@@ -52,6 +52,7 @@ import org.aspectj.weaver.patterns.Pointcut;
 import org.aspectj.weaver.patterns.SimpleScope;
 import org.aspectj.weaver.patterns.TypePattern;
 import org.aspectj.weaver.patterns.PerFromSuper;
+import org.aspectj.weaver.patterns.PointcutVisitor;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -1331,7 +1332,7 @@ public class AtAjAttributes {
             pointcut.setLocation(location.context, -1, -1);//FIXME -1,-1 is not good enough
             return pointcut;
         } catch (ParserException e) {
-            reportError("Invalid pointcut '" + pointcutString + "' : " + e.getLocation(), location);
+            reportError("Invalid pointcut '" + pointcutString + "': " + e.toString(), location);
             return null;
         }
     }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AndAnnotationTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/AndAnnotationTypePattern.java
index 018a0e8fc..077840632 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AndAnnotationTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AndAnnotationTypePattern.java
@@ -89,4 +89,7 @@ public class AndAnnotationTypePattern extends AnnotationTypePattern {
 	public AnnotationTypePattern getLeft() { return left; }
 	public AnnotationTypePattern getRight() { return right; }
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java b/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
index 4bb8b1ce4..a688e66b9 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
@@ -146,4 +146,7 @@ public class AndPointcut extends Pointcut {
 		return right;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AndTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/AndTypePattern.java
index 022ba5570..b56817b7f 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AndTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AndTypePattern.java
@@ -30,7 +30,7 @@ import org.aspectj.weaver.VersionedDataInputStream;
  * @author Jim Hugunin
  */
 public class AndTypePattern extends TypePattern {
-	private TypePattern left, right;
+	TypePattern left, right;
 	
 	public AndTypePattern(TypePattern left, TypePattern right) {
 		super(false,false);  //?? we override all methods that care about includeSubtypes
@@ -160,5 +160,9 @@ public class AndTypePattern extends TypePattern {
 		ret = ret + 37 * right.hashCode();
 		return ret;
 	}
-	
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AnnotationPatternList.java b/weaver/src/org/aspectj/weaver/patterns/AnnotationPatternList.java
index df3833009..75dbb73a8 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AnnotationPatternList.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AnnotationPatternList.java
@@ -176,5 +176,9 @@ public class AnnotationPatternList extends PatternNode {
 		}
 		writeLocation(s);
 	}
-   
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AnnotationPointcut.java b/weaver/src/org/aspectj/weaver/patterns/AnnotationPointcut.java
index b7c8ed7b4..ae611aea2 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AnnotationPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AnnotationPointcut.java
@@ -60,7 +60,7 @@ import org.aspectj.weaver.bcel.BcelTypeMunger;
  */
 public class AnnotationPointcut extends NameBindingPointcut {
 
-	private ExactAnnotationTypePattern annotationTypePattern;
+	ExactAnnotationTypePattern annotationTypePattern;
     private ShadowMunger munger = null; // only set after concretization
 	
 	public AnnotationPointcut(ExactAnnotationTypePattern type) {
@@ -262,4 +262,8 @@ public class AnnotationPointcut extends NameBindingPointcut {
 		return buf.toString();
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/AnnotationTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/AnnotationTypePattern.java
index df25c75fb..831c6f8c4 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AnnotationTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AnnotationTypePattern.java
@@ -99,6 +99,11 @@ class AnyAnnotationTypePattern extends AnnotationTypePattern {
 	}
 	
 	public String toString() { return "@ANY"; }
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+    
 }
 
 class EllipsisAnnotationTypePattern extends AnnotationTypePattern {
@@ -115,4 +120,9 @@ class EllipsisAnnotationTypePattern extends AnnotationTypePattern {
 	}
 
 	public String toString() { return ".."; }
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+    
 }
\ No newline at end of file
diff --git a/weaver/src/org/aspectj/weaver/patterns/ArgsAnnotationPointcut.java b/weaver/src/org/aspectj/weaver/patterns/ArgsAnnotationPointcut.java
index ce9125476..dc9d43993 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ArgsAnnotationPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ArgsAnnotationPointcut.java
@@ -39,7 +39,7 @@ import org.aspectj.weaver.ast.Var;
  */
 public class ArgsAnnotationPointcut extends NameBindingPointcut {
 
-	private AnnotationPatternList arguments;
+	AnnotationPatternList arguments;
 
 	/**
 	 * 
@@ -216,4 +216,8 @@ public class ArgsAnnotationPointcut extends NameBindingPointcut {
         buf.append(arguments.toString());
         return buf.toString();
     }
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ArgsPointcut.java b/weaver/src/org/aspectj/weaver/patterns/ArgsPointcut.java
index 15198d92d..1a30fdd72 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ArgsPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ArgsPointcut.java
@@ -303,4 +303,8 @@ public class ArgsPointcut extends NameBindingPointcut {
 	public String toString() {
 		return "args" + arguments.toString() + "";
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/CflowPointcut.java b/weaver/src/org/aspectj/weaver/patterns/CflowPointcut.java
index f6133bc71..3b0611adc 100644
--- a/weaver/src/org/aspectj/weaver/patterns/CflowPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/CflowPointcut.java
@@ -44,7 +44,7 @@ import org.aspectj.weaver.ast.Test;
 
 public class CflowPointcut extends Pointcut {
 	private Pointcut entry; // The pointcut inside the cflow() that represents the 'entry' point
-	private boolean isBelow;// Is this cflowbelow?
+	boolean isBelow;// Is this cflowbelow?
 	private int[] freeVars;
 	
 	private static Hashtable cflowFields = new Hashtable();
@@ -308,4 +308,8 @@ public class CflowPointcut extends Pointcut {
 		}
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ConcreteCflowPointcut.java b/weaver/src/org/aspectj/weaver/patterns/ConcreteCflowPointcut.java
index 9c1309c74..360b6456f 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ConcreteCflowPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ConcreteCflowPointcut.java
@@ -140,6 +140,10 @@ public class ConcreteCflowPointcut extends Pointcut {
 		throw new RuntimeException("unimplemented");
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 
 	public static class Slot {
 		int formalIndex;
diff --git a/weaver/src/org/aspectj/weaver/patterns/ExactAnnotationTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/ExactAnnotationTypePattern.java
index 8e1b17d17..f098d36f6 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ExactAnnotationTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ExactAnnotationTypePattern.java
@@ -221,4 +221,8 @@ public class ExactAnnotationTypePattern extends AnnotationTypePattern {
 		if (formalName != null) ret = ret + " " + formalName;
 		return ret;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
index 6776579f3..d9e814003 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
@@ -262,4 +262,8 @@ public class ExactTypePattern extends TypePattern {
 		throw new IllegalStateException("trying to re-resolve");
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/HandlerPointcut.java b/weaver/src/org/aspectj/weaver/patterns/HandlerPointcut.java
index 0c3b80385..8cc32353c 100644
--- a/weaver/src/org/aspectj/weaver/patterns/HandlerPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/HandlerPointcut.java
@@ -156,4 +156,8 @@ public class HandlerPointcut extends Pointcut {
 		ret.copyLocationFrom(this);
 		return ret;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/IdentityPointcutVisitor.java b/weaver/src/org/aspectj/weaver/patterns/IdentityPointcutVisitor.java
new file mode 100644
index 000000000..a05fe013f
--- /dev/null
+++ b/weaver/src/org/aspectj/weaver/patterns/IdentityPointcutVisitor.java
@@ -0,0 +1,234 @@
+/*******************************************************************************
+ * 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:
+ *   Alexandre Vasseur         initial implementation
+ *******************************************************************************/
+package org.aspectj.weaver.patterns;
+
+/**
+ * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+ */
+public class IdentityPointcutVisitor implements PointcutVisitor {
+
+    public Object visit(AnyTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(NoTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(EllipsisTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(AnyWithAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(AnyAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(EllipsisAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(AndAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(AndPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(AndTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(AnnotationPatternList node, Object data) {
+        return node;
+    }
+
+    public Object visit(AnnotationPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ArgsAnnotationPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ArgsPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(BindingAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(BindingTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(CflowPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ConcreteCflowPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(DeclareAnnotation node, Object data) {
+        return node;
+    }
+
+    public Object visit(DeclareErrorOrWarning node, Object data) {
+        return node;
+    }
+
+    public Object visit(DeclareParents node, Object data) {
+        return node;
+    }
+
+    public Object visit(DeclarePrecedence node, Object data) {
+        return node;
+    }
+
+    public Object visit(DeclareSoft node, Object data) {
+        return node;
+    }
+
+    public Object visit(ExactAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(ExactTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(HandlerPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(IfPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(KindedPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ModifiersPattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(NamePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(NotAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(NotPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(NotTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(OrAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(OrPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(OrTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(PerCflow node, Object data) {
+        return node;
+    }
+
+    public Object visit(PerFromSuper node, Object data) {
+        return node;
+    }
+
+    public Object visit(PerObject node, Object data) {
+        return node;
+    }
+
+    public Object visit(PerSingleton node, Object data) {
+        return node;
+    }
+
+    public Object visit(PerTypeWithin node, Object data) {
+        return node;
+    }
+
+    public Object visit(PatternNode node, Object data) {
+        throw new ParserException("Should implement for " + node.getClass(), null);
+    }
+
+    public Object visit(ReferencePointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(SignaturePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(ThisOrTargetAnnotationPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ThisOrTargetPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(ThrowsPattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(TypePatternList node, Object data) {
+        return node;
+    }
+
+    public Object visit(WildAnnotationTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(WildTypePattern node, Object data) {
+        return node;
+    }
+
+    public Object visit(WithinAnnotationPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(WithinCodeAnnotationPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(WithinPointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(WithincodePointcut node, Object data) {
+        return node;
+    }
+
+    public Object visit(Pointcut.MatchesNothingPointcut node, Object data) {
+        return node;
+    }
+}
diff --git a/weaver/src/org/aspectj/weaver/patterns/IfPointcut.java b/weaver/src/org/aspectj/weaver/patterns/IfPointcut.java
index 39d2fdb8c..9a716e6e6 100644
--- a/weaver/src/org/aspectj/weaver/patterns/IfPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/IfPointcut.java
@@ -277,6 +277,10 @@ public class IfPointcut extends Pointcut {
 		return ret;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 	private static class IfFalsePointcut extends IfPointcut {
 		
 		public IfFalsePointcut() {
diff --git a/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java b/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
index 26749020b..61123362a 100644
--- a/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
@@ -311,4 +311,7 @@ public class KindedPointcut extends Pointcut {
 		return kind;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ModifiersPattern.java b/weaver/src/org/aspectj/weaver/patterns/ModifiersPattern.java
index ad11cfd12..a3f5eedce 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ModifiersPattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ModifiersPattern.java
@@ -93,4 +93,7 @@ public class ModifiersPattern extends PatternNode {
 		return flag.intValue();
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/NamePattern.java b/weaver/src/org/aspectj/weaver/patterns/NamePattern.java
index 9ede44bf2..a2879b1ea 100644
--- a/weaver/src/org/aspectj/weaver/patterns/NamePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/NamePattern.java
@@ -158,4 +158,7 @@ public class NamePattern extends PatternNode {
 		return starCount == 1 && pattern.length == 1;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/NotAnnotationTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/NotAnnotationTypePattern.java
index 694cf4652..37acaa16b 100644
--- a/weaver/src/org/aspectj/weaver/patterns/NotAnnotationTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/NotAnnotationTypePattern.java
@@ -20,7 +20,7 @@ import org.aspectj.weaver.World;
 
 public class NotAnnotationTypePattern extends AnnotationTypePattern {
 
-	private AnnotationTypePattern negatedPattern;
+	AnnotationTypePattern negatedPattern;
 	
 	public NotAnnotationTypePattern(AnnotationTypePattern pattern) {
 		this.negatedPattern = pattern;
@@ -83,4 +83,8 @@ public class NotAnnotationTypePattern extends AnnotationTypePattern {
 	public AnnotationTypePattern getNegatedPattern() {
 		return negatedPattern;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java b/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
index bdbecfcbf..47baa7acf 100644
--- a/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
@@ -133,4 +133,8 @@ public class NotPointcut extends Pointcut {
 		return ret;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/NotTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/NotTypePattern.java
index 4106af216..bfd9dad5e 100644
--- a/weaver/src/org/aspectj/weaver/patterns/NotTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/NotTypePattern.java
@@ -32,7 +32,7 @@ import org.aspectj.weaver.VersionedDataInputStream;
  * @author Jim Hugunin
  */
 public class NotTypePattern extends TypePattern {
-	private TypePattern pattern;
+	TypePattern pattern;
 	
 	public NotTypePattern(TypePattern pattern) {
 		super(false,false);  //??? we override all methods that care about includeSubtypes
@@ -145,4 +145,8 @@ public class NotTypePattern extends TypePattern {
 	public int hashCode() {
 		return 17 + 37 * pattern.hashCode();
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java b/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
index d5fd12471..12abd441b 100644
--- a/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
@@ -29,7 +29,7 @@ import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Test;
 
 public class OrPointcut extends Pointcut {
-	private Pointcut left, right;
+	Pointcut left, right;
 	private Set couldMatchKinds;
 
 	public OrPointcut(Pointcut left, Pointcut right) {
@@ -147,4 +147,8 @@ public class OrPointcut extends Pointcut {
 	public Pointcut getRight() {
 		return right;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/OrTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/OrTypePattern.java
index e5e372d80..a23c2fbe7 100644
--- a/weaver/src/org/aspectj/weaver/patterns/OrTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/OrTypePattern.java
@@ -30,7 +30,7 @@ import org.aspectj.weaver.VersionedDataInputStream;
  * @author Jim Hugunin
  */
 public class OrTypePattern extends TypePattern {
-	private TypePattern left, right;
+	TypePattern left, right;
 	
 	public OrTypePattern(TypePattern left, TypePattern right) {
 		super(false,false);  //??? we override all methods that care about includeSubtypes
@@ -167,4 +167,8 @@ public class OrTypePattern extends TypePattern {
 		ret = ret + 37 * right.hashCode();
 		return ret;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/PatternNode.java b/weaver/src/org/aspectj/weaver/patterns/PatternNode.java
index 0730538ca..817064123 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PatternNode.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PatternNode.java
@@ -80,4 +80,8 @@ public abstract class PatternNode implements IHasSourceLocation {
 		end = s.readInt();
 		this.sourceContext = context;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/PatternParser.java b/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
index c620159f5..0f00b5ab7 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
@@ -219,7 +219,8 @@ public class PatternParser {
 		
 		if (maybeEat("||")) {
 			p = new OrPointcut(p, parsePointcut());
-		}		
+		}
+
 		return p;
 	}
 	
diff --git a/weaver/src/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java b/weaver/src/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java
new file mode 100644
index 000000000..bddb7efcc
--- /dev/null
+++ b/weaver/src/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java
@@ -0,0 +1,215 @@
+/*******************************************************************************
+ * 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:
+ *   Alexandre Vasseur         initial implementation
+ *******************************************************************************/
+package org.aspectj.weaver.patterns;
+
+import org.aspectj.weaver.Member;
+import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.ResolvedPointcutDefinition;
+import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.World;
+
+/**
+ * A visitor that turns a pointcut into a type pattern equivalent for a perthis or pertarget matching:
+ * - pertarget(target(Foo)) => Foo+ (this one is a special case..)
+ * - pertarget(execution(* Foo.do()) => Foo
+ * - perthis(call(* Foo.do()) => *
+ * - perthis(!call(* Foo.do()) => * (see how the ! has been absorbed here..)
+ *
+ * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+ */
+public class PerThisOrTargetPointcutVisitor extends IdentityPointcutVisitor {
+
+    /** A maybe marker */
+    private final static TypePattern MAYBE = new TypePatternMayBe();
+
+    private final boolean m_isTarget;
+    private final ResolvedTypeX m_fromAspectType;
+
+    public PerThisOrTargetPointcutVisitor(boolean isTarget, ResolvedTypeX fromAspectType) {
+        m_isTarget = isTarget;
+        m_fromAspectType = fromAspectType;
+    }
+
+    public TypePattern getPerTypePointcut(Pointcut perClausePointcut) {
+        return (TypePattern) perClausePointcut.accept(this, perClausePointcut);
+    }
+
+    //-- visitor methods, all is like Identity visitor except when it comes to transform pointcuts
+
+    public Object visit(WithinPointcut node, Object data) {
+        if (m_isTarget) {
+            //pertarget(.. &&  within(Foo)) => true
+            //pertarget(.. && !within(Foo)) => true as well !
+            return MAYBE;
+        } else {
+            return node.typePattern;
+        }
+    }
+
+    public Object visit(WithincodePointcut node, Object data) {
+        if (m_isTarget) {
+            //pertarget(.. &&  withincode(* Foo.do())) => true
+            //pertarget(.. && !withincode(* Foo.do())) => true as well !
+            return MAYBE;
+        } else {
+            return node.signature.getDeclaringType();
+        }
+    }
+
+    public Object visit(WithinAnnotationPointcut node, Object data) {
+        if (m_isTarget) {
+            return MAYBE;
+        } else {
+            return node.annotationTypePattern;
+        }
+    }
+
+    public Object visit(WithinCodeAnnotationPointcut node, Object data) {
+        if (m_isTarget) {
+            return MAYBE;
+        } else {
+            return MAYBE;//FIXME AV - can we optimize ? perthis(@withincode(Foo)) = hasmethod(..)
+        }
+    }
+
+    public Object visit(KindedPointcut node, Object data) {
+        if (node.getKind().equals(Shadow.AdviceExecution)) {
+            return MAYBE;//TODO AV - can we do better ?
+        } else if (node.getKind().equals(Shadow.ConstructorExecution)
+                    || node.getKind().equals(Shadow.Initialization)
+                    || node.getKind().equals(Shadow.MethodExecution)
+                    || node.getKind().equals(Shadow.PreInitialization)
+                    || node.getKind().equals(Shadow.StaticInitialization)) {
+            return node.signature.getDeclaringType();
+        } else if (node.getKind().equals(Shadow.ConstructorCall)
+                   || node.getKind().equals(Shadow.FieldGet)
+                   || node.getKind().equals(Shadow.FieldSet)
+                   || node.getKind().equals(Shadow.MethodCall)) {
+            if (m_isTarget) {
+                return node.signature.getDeclaringType();
+            } else {
+                return MAYBE;
+            }
+        } else if (node.getKind().equals(Shadow.ExceptionHandler)) {
+            return MAYBE;
+        } else {
+            throw new ParserException("Undetermined - should not happen: " + node.getKind().getSimpleName(), null);
+        }
+    }
+
+    public Object visit(AndPointcut node, Object data) {
+        return new AndTypePattern(getPerTypePointcut(node.left), getPerTypePointcut(node.right));
+    }
+
+    public Object visit(OrPointcut node, Object data) {
+        return new OrTypePattern(getPerTypePointcut(node.left), getPerTypePointcut(node.right));
+    }
+
+    public Object visit(NotPointcut node, Object data) {
+        TypePattern negated = getPerTypePointcut(node.getNegatedPointcut());
+        if (MAYBE.equals(negated)) {
+            return MAYBE;
+        }
+        return new NotTypePattern(negated);
+    }
+
+    public Object visit(ThisOrTargetAnnotationPointcut node, Object data) {
+        if (m_isTarget && !node.isThis()) {
+            return node.annotationTypePattern;
+        } else if (!m_isTarget && node.isThis()) {
+            return node.annotationTypePattern;
+        } else {
+            // perthis(@target(Foo))
+            return MAYBE;
+        }
+    }
+
+    public Object visit(ThisOrTargetPointcut node, Object data) {
+        if ((m_isTarget && !node.isThis())
+            || (!m_isTarget && node.isThis())) {
+            //pertarget(target(Foo)) => Foo+ for type pattern matching
+            //perthis(this(Foo)) => Foo+ for type pattern matching
+            // TODO AV - we do like a deep copy by parsing it again.. quite dirty, would need a clean deep copy
+            TypePattern copy = new PatternParser(node.type.toString()).parseTypePattern();
+            copy.includeSubtypes = true;
+            return copy;
+        } else {
+            // perthis(target(Foo)) => maybe
+            return MAYBE;
+        }
+    }
+
+    public Object visit(ReferencePointcut node, Object data) {
+        // && pc_ref()
+        // we know there is no support for binding in perClause: perthis(pc_ref(java.lang.String))
+        // TODO AV - may need some work for generics..
+
+        ResolvedPointcutDefinition pointcutDec;
+        ResolvedTypeX searchStart = m_fromAspectType;
+        if (node.onType != null) {
+            searchStart = node.onType.resolve(m_fromAspectType.getWorld());
+            if (searchStart == ResolvedTypeX.MISSING) {
+                return MAYBE;// this should not happen since concretize will fails but just in case..
+            }
+        }
+        pointcutDec = searchStart.findPointcut(node.name);
+
+        return getPerTypePointcut(pointcutDec.getPointcut());
+    }
+
+    public Object visit(IfPointcut node, Object data) {
+        return TypePattern.ANY;
+    }
+
+    public Object visit(HandlerPointcut node, Object data) {
+        // quiet unexpected since a KindedPointcut but do as if...
+        return MAYBE;
+    }
+
+    public Object visit(CflowPointcut node, Object data) {
+        return MAYBE;
+    }
+
+    public Object visit(ConcreteCflowPointcut node, Object data) {
+        return MAYBE;
+    }
+
+    public Object visit(ArgsPointcut node, Object data) {
+        return MAYBE;
+    }
+
+    public Object visit(ArgsAnnotationPointcut node, Object data) {
+        return MAYBE;
+    }
+
+    public Object visit(AnnotationPointcut node, Object data) {
+        return MAYBE;
+    }
+
+    public Object visit(Pointcut.MatchesNothingPointcut node, Object data) {
+        // a small hack since the usual MatchNothing has its toString = "<nothing>" which is not parseable back
+        // while I use back parsing for check purpose.
+        return new NoTypePattern() {
+            public String toString() {
+                return "false";
+            }
+        };
+    }
+
+    /**
+     * A MayBe type pattern that acts as ANY except that !MAYBE = MAYBE
+     *
+     * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+     */
+    private static class TypePatternMayBe extends AnyTypePattern {
+    }
+}
diff --git a/weaver/src/org/aspectj/weaver/patterns/Pointcut.java b/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
index cc5e86762..886d1af9d 100644
--- a/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
@@ -353,7 +353,7 @@ public abstract class Pointcut extends PatternNode implements PointcutExpression
         return parser.parsePointcut();
     }
     
-    private static class MatchesNothingPointcut extends Pointcut {
+    static class MatchesNothingPointcut extends Pointcut {
     	protected Test findResidueInternal(Shadow shadow, ExposedState state) {
 			return Literal.FALSE; // can only get here if an earlier error occurred
 		}
@@ -412,6 +412,10 @@ public abstract class Pointcut extends PatternNode implements PointcutExpression
 		}
 		
 		public String toString() { return ""; }
+
+        public Object accept(PointcutVisitor visitor, Object data) {
+            return visitor.visit(this, data);
+        }
 	}
     
     //public static Pointcut MatchesNothing = new MatchesNothingPointcut();
diff --git a/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java b/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java
new file mode 100644
index 000000000..9faba4a27
--- /dev/null
+++ b/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java
@@ -0,0 +1,623 @@
+/*******************************************************************************
+ * 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:
+ *   Alexandre Vasseur         initial implementation
+ *******************************************************************************/
+package org.aspectj.weaver.patterns;
+
+import org.aspectj.weaver.Member;
+
+import java.io.OutputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/**
+ * A Pointcut or TypePattern visitor
+ *
+ * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+ */
+public interface PointcutVisitor {
+
+    Object visit(AnyTypePattern node, Object data);
+
+    Object visit(NoTypePattern node, Object data);
+
+    Object visit(EllipsisTypePattern node, Object data);
+
+    Object visit(AnyWithAnnotationTypePattern node, Object data);
+
+    Object visit(AnyAnnotationTypePattern node, Object data);
+
+    Object visit(EllipsisAnnotationTypePattern node, Object data);
+
+    Object visit(AndAnnotationTypePattern node, Object data);
+
+    Object visit(AndPointcut node, Object data);
+
+    Object visit(AndTypePattern node, Object data);
+
+    Object visit(AnnotationPatternList node, Object data);
+
+    Object visit(AnnotationPointcut node, Object data);
+
+    Object visit(ArgsAnnotationPointcut node, Object data);
+
+    Object visit(ArgsPointcut node, Object data);
+
+    Object visit(BindingAnnotationTypePattern node, Object data);
+
+    Object visit(BindingTypePattern node, Object data);
+
+    Object visit(CflowPointcut node, Object data);
+
+    Object visit(ConcreteCflowPointcut node, Object data);
+
+    Object visit(DeclareAnnotation node, Object data);
+
+    Object visit(DeclareErrorOrWarning node, Object data);
+
+    Object visit(DeclareParents node, Object data);
+
+    Object visit(DeclarePrecedence node, Object data);
+
+    Object visit(DeclareSoft node, Object data);
+
+    Object visit(ExactAnnotationTypePattern node, Object data);
+
+    Object visit(ExactTypePattern node, Object data);
+
+    Object visit(HandlerPointcut node, Object data);
+
+    Object visit(IfPointcut node, Object data);
+
+    Object visit(KindedPointcut node, Object data);
+
+    Object visit(ModifiersPattern node, Object data);
+
+    Object visit(NamePattern node, Object data);
+
+    Object visit(NotAnnotationTypePattern node, Object data);
+
+    Object visit(NotPointcut node, Object data);
+
+    Object visit(NotTypePattern node, Object data);
+
+    Object visit(OrAnnotationTypePattern node, Object data);
+
+    Object visit(OrPointcut node, Object data);
+
+    Object visit(OrTypePattern node, Object data);
+
+    Object visit(PerCflow node, Object data);
+
+    Object visit(PerFromSuper node, Object data);
+
+    Object visit(PerObject node, Object data);
+
+    Object visit(PerSingleton node, Object data);
+
+    Object visit(PerTypeWithin node, Object data);
+
+    Object visit(PatternNode node, Object data);
+
+    Object visit(ReferencePointcut node, Object data);
+
+    Object visit(SignaturePattern node, Object data);
+
+    Object visit(ThisOrTargetAnnotationPointcut node, Object data);
+
+    Object visit(ThisOrTargetPointcut node, Object data);
+
+    Object visit(ThrowsPattern node, Object data);
+
+    Object visit(TypePatternList node, Object data);
+
+    Object visit(WildAnnotationTypePattern node, Object data);
+
+    Object visit(WildTypePattern node, Object data);
+
+    Object visit(WithinAnnotationPointcut node, Object data);
+
+    Object visit(WithinCodeAnnotationPointcut node, Object data);
+
+    Object visit(WithinPointcut node, Object data);
+
+    Object visit(WithincodePointcut node, Object data);
+
+    Object visit(Pointcut.MatchesNothingPointcut node, Object data);
+
+    /**
+     * A sample toString like visitor that helps understanding the AST tree structure organization
+     * TODO: not yet complete
+     *
+     * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+     */
+    static class DumpPointcutVisitor implements PointcutVisitor {
+
+        private StringBuffer sb = new StringBuffer();
+        public String get() {
+            return sb.toString();
+        }
+
+        private void p(Object o) {
+            sb.append(o.toString());
+        }
+
+        /**
+         * This method helps maintaining the API and raises warning when PatternNode subclasses do not
+         * implement the visitor pattern
+         *
+         * @param node
+         * @param data
+         * @return
+         */
+        public Object visit(PatternNode node, Object data) {
+            System.err.println("Should implement: "  + node.getClass());
+            return null;
+        }
+
+        public Object visit(AnyTypePattern node, Object data) {
+            p('*');
+            return null;
+        }
+
+        public Object visit(NoTypePattern node, Object data) {
+            p(node.toString());//TODO no idea when this one is used
+            return null;
+        }
+
+        public Object visit(EllipsisTypePattern node, Object data) {
+            p(node.toString());
+            return null;
+        }
+
+        public Object visit(AnyWithAnnotationTypePattern node, Object data) {
+            node.annotationPattern.accept(this, data);
+            p(" *");
+            return null;
+        }
+
+        public Object visit(AnyAnnotationTypePattern node, Object data) {
+            //@ANY : ignore
+            return null;
+        }
+
+        public Object visit(EllipsisAnnotationTypePattern node, Object data) {
+            p("..");
+            return null;
+        }
+
+        public Object visit(AndAnnotationTypePattern node, Object data) {
+            p('(');
+            node.getLeft().accept(this, data);
+            p(" && ");
+            node.getRight().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(AndPointcut node, Object data) {
+            p('(');
+            node.getLeft().accept(this, data);
+            p(" && ");
+            node.getRight().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(AndTypePattern node, Object data) {
+            p('(');
+            node.left.accept(this, data);
+            p(" && ");
+            node.right.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(AnnotationPatternList node, Object data) {
+            AnnotationTypePattern[] annotations = node.getAnnotationPatterns();
+            for (int i = 0; i < annotations.length; i++) {
+                annotations[i].accept(this, data);
+                p(' ');
+            }
+            return null;
+        }
+
+        public Object visit(AnnotationPointcut node, Object data) {
+            p("@annotation(");
+            node.annotationTypePattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ArgsAnnotationPointcut node, Object data) {
+            p("@args(");
+            node.arguments.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ArgsPointcut node, Object data) {
+            p("args(");
+            node.arguments.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(BindingAnnotationTypePattern node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(BindingTypePattern node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(CflowPointcut node, Object data) {
+            p(node.isBelow?"cflowbelow(":"cflow(");
+            node.getEntry().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ExactAnnotationTypePattern node, Object data) {
+            p('@');
+            p(node.annotationType.getName());
+            return null;
+        }
+
+        public Object visit(ExactTypePattern node, Object data) {
+            if (node.annotationPattern != AnnotationTypePattern.ANY) {
+                p('(');
+                node.annotationPattern.accept(this, data);
+                p(' ');
+            }
+
+            String typeString = node.type.toString();
+            if (node.isVarArgs) typeString = typeString.substring(0, typeString.lastIndexOf('['));//TODO AV - ugly
+            p(typeString);
+            if (node.includeSubtypes) p('+');
+            if (node.isVarArgs) p("...");
+            if (node.annotationPattern != AnnotationTypePattern.ANY) {
+                p(')');
+            }
+            return null;
+        }
+
+        public Object visit(KindedPointcut node, Object data) {
+            p(node.getKind().getSimpleName());
+            p('(');
+            node.signature.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ModifiersPattern node, Object data) {
+            p(node.toString());//note: node takes care of forbidden mods
+            return null;
+        }
+
+        public Object visit(NamePattern node, Object data) {
+            p(node.toString());
+            return null;
+        }
+
+        public Object visit(NotAnnotationTypePattern node, Object data) {
+            p("!(");
+            node.negatedPattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(NotPointcut node, Object data) {
+            p("!(");
+            node.getNegatedPointcut().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(NotTypePattern node, Object data) {
+            p("!(");
+            node.pattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(OrAnnotationTypePattern node, Object data) {
+            p('(');
+            node.getLeft().accept(this, data);
+            p(" || ");
+            node.getRight().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(OrPointcut node, Object data) {
+            p('(');
+            node.getLeft().accept(this, data);
+            p(" || ");
+            node.getRight().accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(OrTypePattern node, Object data) {
+            p('(');
+            node.left.accept(this, data);
+            p(" || ");
+            node.right.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ReferencePointcut node, Object data) {
+            p(node.toString());
+            return null;
+        }
+
+        public Object visit(SignaturePattern node, Object data) {
+            if (node.getAnnotationPattern() != AnnotationTypePattern.ANY) {
+                node.getAnnotationPattern().accept(this, data);
+                p(' ');
+            }
+
+            if (node.getModifiers() != ModifiersPattern.ANY) {
+                node.getModifiers().accept(this, data);
+                p(' ');
+            }
+
+            if (node.getKind() == Member.STATIC_INITIALIZATION) {
+                node.getDeclaringType().accept(this, data);
+                p(".<clinit>()");
+            } else if (node.getKind() == Member.HANDLER) {
+                p("handler(");
+                node.getParameterTypes().get(0).accept(this, data);//Note: we know we have 1 child
+                p(')');
+            } else {
+                if (!(node.getKind() == Member.CONSTRUCTOR)) {
+                    node.getReturnType().accept(this, data);
+                    p(' ');
+                }
+                if (node.getDeclaringType() != TypePattern.ANY) {
+                    node.getDeclaringType().accept(this, data);
+                    p('.');
+                }
+                if (node.getKind() == Member.CONSTRUCTOR) {
+                    p("new");
+                } else {
+                    node.getName().accept(this, data);
+                }
+                if (node.getKind() == Member.METHOD || node.getKind() == Member.CONSTRUCTOR) {
+                    p('(');
+                    node.getParameterTypes().accept(this, data);
+                    p(')');
+                }
+                if (node.getThrowsPattern() != null) {
+                    p(' ');
+                    node.getThrowsPattern().accept(this, data);
+                }
+            }
+            return null;
+        }
+
+        public Object visit(ThisOrTargetAnnotationPointcut node, Object data) {
+            p(node.isThis() ? "@this(" : "@target(");
+            node.annotationTypePattern.accept(this, data);
+            //buf.append(annPatt.startsWith("@") ? annPatt.substring(1) : annPatt);
+            p(')');
+            return null;
+        }
+
+        public Object visit(ThisOrTargetPointcut node, Object data) {
+            p(node.isThis() ? "this(" : "target(");
+            node.type.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        private boolean inThrowsForbidden = false;
+
+        public Object visit(ThrowsPattern node, Object data) {
+            if (node == ThrowsPattern.ANY) return null;
+
+            p("throws ");
+            node.required.accept(this, data);
+            if (node.forbidden.size() > 0) {
+                // a hack since throws !(A, B) cannot be parsed
+                inThrowsForbidden = true;
+                node.forbidden.accept(this, data);
+                inThrowsForbidden = false;
+            }
+            return null;
+        }
+
+        public Object visit(TypePatternList node, Object data) {
+            if (node.getTypePatterns().length == 0) return null;
+
+            TypePattern[] typePatterns = node.getTypePatterns();
+            for (int i = 0; i < typePatterns.length; i++) {
+                TypePattern typePattern = typePatterns[i];
+                if (i > 0) p(", ");
+                if (inThrowsForbidden) p('!');
+                typePattern.accept(this, data);
+            }
+            return null;
+        }
+
+        public Object visit(WildAnnotationTypePattern node, Object data) {
+            p("@(");
+            node.typePattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(WildTypePattern node, Object data) {
+            if (node.annotationPattern != AnnotationTypePattern.ANY) {
+                p('(');
+                node.annotationPattern.accept(this, data);
+                p(' ');
+            }
+            for (int i=0, len=node.namePatterns.length; i < len; i++) {
+                NamePattern name = node.namePatterns[i];
+                if (name == null) {
+                    p('.');//FIXME mh, error prone, can't we have a nullNamePattern ?
+                } else {
+                    if (i > 0) p('.');
+                    name.accept(this, data);
+                }
+            }
+            if (node.includeSubtypes) p('+');
+            if (node.isVarArgs) p("...");//FIXME ? in type pattern
+            if (node.annotationPattern != AnnotationTypePattern.ANY) {
+                p(')');
+            }
+            return null;
+        }
+
+        public Object visit(WithinAnnotationPointcut node, Object data) {
+            p("@within(");
+            node.annotationTypePattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(WithinCodeAnnotationPointcut node, Object data) {
+            p("@withincode(");
+            node.annotationTypePattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(WithinPointcut node, Object data) {
+            p("within(");
+            node.typePattern.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(WithincodePointcut node, Object data) {
+            p("withincode(");
+            node.signature.accept(this, data);
+            p(')');
+            return null;
+        }
+
+        public Object visit(Pointcut.MatchesNothingPointcut node, Object data) {
+            p("");//TODO shouldn't that be a "false" ?
+            return null;
+        }
+
+
+        //-------------- perX
+
+        public Object visit(PerCflow node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(PerFromSuper node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(PerObject node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(PerSingleton node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(PerTypeWithin node, Object data) {
+            p(node);
+            return null;
+        }
+
+        // ------------- declare X
+
+        public Object visit(DeclareAnnotation node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(DeclareErrorOrWarning node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(DeclareParents node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(DeclarePrecedence node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(DeclareSoft node, Object data) {
+            p(node);
+            return null;
+        }
+
+        // ----------- misc
+
+        public Object visit(ConcreteCflowPointcut node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(HandlerPointcut node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public Object visit(IfPointcut node, Object data) {
+            p(node);
+            return null;
+        }
+
+        public static void check(String s) {
+            check(Pointcut.fromString(s), false);
+        }
+
+        public static void check(PatternNode pc, boolean isTypePattern) {
+            DumpPointcutVisitor v1 = new DumpPointcutVisitor();
+            pc.accept(v1, null);
+
+            DumpPointcutVisitor v2 = new DumpPointcutVisitor();
+            final PatternNode pc2;
+            if (isTypePattern) {
+                pc2 = new PatternParser(v1.get()).parseTypePattern();
+            } else {
+                pc2 = Pointcut.fromString(v1.get());
+            }
+            pc2.accept(v2, null);
+
+            // at second parsing, the String form stay stable when parsed and parsed again
+            if (! v1.get().equals(v2.get())) {
+                throw new ParserException("Unstable back parsing for '"+pc+"', got '" + v1.get() + "' and '" + v2.get() + "'", null);
+            }
+        }
+
+        public static void main(String args[]) throws Throwable {
+            String s = "execution(* foo.bar.do() throws !(@An Waza), !Bla)";
+            check(s);
+        }
+
+    }
+
+}
diff --git a/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java b/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
index c510cf5be..1b18cced8 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
@@ -312,5 +312,7 @@ public class ReferencePointcut extends Pointcut {
         return result;
     }
 
-
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
index 13f8be048..0b0e4d980 100644
--- a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
@@ -512,6 +512,7 @@ public class SignaturePattern extends PatternNode {
     		if (kind == Member.METHOD || kind == Member.CONSTRUCTOR) {
     			buf.append(parameterTypes.toString());
     		}
+            //FIXME AV - throws is not printed here, weird
     	}
     	return buf.toString();
     }
@@ -624,4 +625,7 @@ public class SignaturePattern extends PatternNode {
 		return annotationPattern == AnnotationTypePattern.ANY;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetAnnotationPointcut.java b/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetAnnotationPointcut.java
index 590c022d3..9310cfe60 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetAnnotationPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetAnnotationPointcut.java
@@ -43,7 +43,7 @@ public class ThisOrTargetAnnotationPointcut extends NameBindingPointcut {
 
 	private boolean isThis;
 	private boolean alreadyWarnedAboutDEoW = false;
-	private ExactAnnotationTypePattern annotationTypePattern;
+	ExactAnnotationTypePattern annotationTypePattern;
 	private ShadowMunger munger;
 	private static final Set thisKindSet = new HashSet(Shadow.ALL_SHADOW_KINDS);
 	private static final Set targetKindSet = new HashSet(Shadow.ALL_SHADOW_KINDS);
@@ -266,4 +266,8 @@ public class ThisOrTargetAnnotationPointcut extends NameBindingPointcut {
 		buf.append(")");
 		return buf.toString();   
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetPointcut.java b/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetPointcut.java
index 8c3dcccfd..f1bb005a3 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ThisOrTargetPointcut.java
@@ -53,7 +53,7 @@ import org.aspectj.weaver.ast.Var;
  */
 public class ThisOrTargetPointcut extends NameBindingPointcut {
 	private boolean isThis;
-	private TypePattern type;
+	TypePattern type;
 
 	private static final Set thisKindSet = new HashSet(Shadow.ALL_SHADOW_KINDS);
 	private static final Set targetKindSet = new HashSet(Shadow.ALL_SHADOW_KINDS);
@@ -228,4 +228,7 @@ public class ThisOrTargetPointcut extends NameBindingPointcut {
 		return ret;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/ThrowsPattern.java b/weaver/src/org/aspectj/weaver/patterns/ThrowsPattern.java
index ea66f5900..a0e7fd244 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ThrowsPattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ThrowsPattern.java
@@ -24,8 +24,8 @@ import org.aspectj.weaver.World;
 
 
 public class ThrowsPattern extends PatternNode {
-	private TypePatternList required;
-	private TypePatternList forbidden;
+	TypePatternList required;
+	TypePatternList forbidden;
 	
 	public static final ThrowsPattern ANY =
 		new ThrowsPattern(TypePatternList.EMPTY, TypePatternList.EMPTY);
@@ -143,4 +143,8 @@ public class ThrowsPattern extends PatternNode {
 		forbidden.write(s);
 		//XXXwriteLocation(s);
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/TypePattern.java b/weaver/src/org/aspectj/weaver/patterns/TypePattern.java
index dd33ef30a..06a5d3069 100644
--- a/weaver/src/org/aspectj/weaver/patterns/TypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/TypePattern.java
@@ -389,6 +389,12 @@ class EllipsisTypePattern extends TypePattern {
 	public int hashCode() {
 		return 17 * 37;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
+
 }
 
 class AnyTypePattern extends TypePattern {
@@ -473,6 +479,10 @@ class AnyTypePattern extends TypePattern {
 	public int hashCode() {
 		return 37;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
 
 /**
@@ -620,7 +630,7 @@ class NoTypePattern extends TypePattern {
 		return false;
 	}
 	
-	public String toString() { return "<nothing>"; }
+	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)
@@ -635,5 +645,9 @@ class NoTypePattern extends TypePattern {
 	public int hashCode() {
 		return 17 * 37 * 37;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
 
diff --git a/weaver/src/org/aspectj/weaver/patterns/TypePatternList.java b/weaver/src/org/aspectj/weaver/patterns/TypePatternList.java
index 67dff9dc1..67327aa3d 100644
--- a/weaver/src/org/aspectj/weaver/patterns/TypePatternList.java
+++ b/weaver/src/org/aspectj/weaver/patterns/TypePatternList.java
@@ -503,4 +503,7 @@ public class TypePatternList extends PatternNode {
 		return ret;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
index 9019954e2..6e23a430c 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java
@@ -31,7 +31,7 @@ import org.aspectj.weaver.World;
  */
 public class WildAnnotationTypePattern extends AnnotationTypePattern {
 
-	private TypePattern typePattern;
+	TypePattern typePattern;
 	private boolean resolved = false;
 	
 	/**
@@ -138,4 +138,8 @@ public class WildAnnotationTypePattern extends AnnotationTypePattern {
 	public String toString() {
 		return "@(" + typePattern.toString() + ")";
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WildTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/WildTypePattern.java
index fd2ec4896..065021651 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WildTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WildTypePattern.java
@@ -686,4 +686,8 @@ public class WildTypePattern extends TypePattern {
 		return ret;
 	}
 
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WithinAnnotationPointcut.java b/weaver/src/org/aspectj/weaver/patterns/WithinAnnotationPointcut.java
index cbcf0e55b..c697eb633 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WithinAnnotationPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WithinAnnotationPointcut.java
@@ -41,7 +41,7 @@ import org.aspectj.weaver.ast.Var;
  */
 public class WithinAnnotationPointcut extends NameBindingPointcut {
 
-	private AnnotationTypePattern annotationTypePattern;
+	AnnotationTypePattern annotationTypePattern;
 	private ShadowMunger munger;
 	
 	/**
@@ -204,4 +204,8 @@ public class WithinAnnotationPointcut extends NameBindingPointcut {
 		buf.append(")");
 		return buf.toString();
     }
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WithinCodeAnnotationPointcut.java b/weaver/src/org/aspectj/weaver/patterns/WithinCodeAnnotationPointcut.java
index edcc5b398..a570ea221 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WithinCodeAnnotationPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WithinCodeAnnotationPointcut.java
@@ -42,7 +42,7 @@ import org.aspectj.weaver.ast.Var;
  */
 public class WithinCodeAnnotationPointcut extends NameBindingPointcut {
 
-	private ExactAnnotationTypePattern annotationTypePattern;
+	ExactAnnotationTypePattern annotationTypePattern;
     private ShadowMunger munger = null; // only set after concretization
     private static final Set matchedShadowKinds = new HashSet();
     static {
@@ -211,4 +211,8 @@ public class WithinCodeAnnotationPointcut extends NameBindingPointcut {
 		buf.append(")");
 		return buf.toString();
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java b/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
index 5e043d438..3a24fce12 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
@@ -169,4 +169,8 @@ public class WithinPointcut extends Pointcut {
 		ret.copyLocationFrom(this);
 		return ret;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/WithincodePointcut.java b/weaver/src/org/aspectj/weaver/patterns/WithincodePointcut.java
index 326567be3..5aed14d77 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WithincodePointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WithincodePointcut.java
@@ -134,4 +134,8 @@ public class WithincodePointcut extends Pointcut {
 		ret.copyLocationFrom(this);
 		return ret;
 	}
+
+    public Object accept(PointcutVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
 }