Fix for Bug 82134: AspectJ 5 M2 should implement backwards compatibility for binary aspect form

tests/src/org/aspectj/systemtest/ajc150/AllTestsJava5_binaryWeaving.java

 	public static Test suite() {
 		TestSuite suite = new TestSuite("Java5 - binary weaving");
 		//$JUnit-BEGIN$
+		suite.addTestSuite(MigrationTests.class);
 		suite.addTest(Ajc150Tests.suite());
 		suite.addTest(AccBridgeMethods.suite());
 		suite.addTestSuite(CovarianceTests.class);

tests/src/org/aspectj/systemtest/ajc150/MigrationTests.java

+/*******************************************************************************
+ * Copyright (c) 2004 IBM 
+ * 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:
+ *    Andy Clement - initial API and implementation
+ *******************************************************************************/
+package org.aspectj.systemtest.ajc150;
+
+import java.io.File;
+
+import org.aspectj.tools.ajc.CompilationResult;
+
+
+/**
+ * Checks if we are obeying migration rules. 
+ */
+public class MigrationTests extends TestUtils {
+	
+  protected void setUp() throws Exception {
+	super.setUp();
+	baseDir = new File("../tests/migration");
+  }
+
+  /**
+   * Compile a simple java class with an aspect library built with aspectj 1.2.1 - this
+   * checks that we can load in attributes (especially pointcuts) that were written out
+   * in the 'old way'
+   *
+   */
+  public void testMigrationFrom121_pointcutsAndAdvice() {
+  	CompilationResult cR = ajc(baseDir,new String[]{"-aspectpath","aspects121.jar","Program.java"});
+  	System.err.println(cR.getStandardError());
+  	assertTrue("Should not coredump: "+cR.getStandardError(),cR.getStandardError().indexOf("Dumping to ajcore")==-1);
+    assertTrue("Should be no error messages: \n"+cR.getErrorMessages(),cR.getErrorMessages().size()==0);
+    File f = new File(ajc.getSandboxDirectory()+File.separator+"Program.class");
+    assertTrue("Missing class file",f.exists());
+  	run("Program");
+  }
+  
+//  /**
+//   * We cannot support all aspects built prior to AspectJ 1.2.1 - so we don't support any.
+//   * There are probably many reasons but the first one I've hit is:
+//   * - Changes for cflow optimizations (counters instead of stacks where we can) mean that an aspect
+//   *   compiled at AspectJ1.2.0 will contain stack cases but AspectJ1.5.0 will look for counter
+//   *   fields in some cases.
+//   * 
+//   * This means we should get a reasonable failure message in this case.
+//   */
+//  public void testMigrationFrom120_pointcutsAndAdvice() {
+//  	CompilationResult cR = ajc(baseDir,new String[]{"-aspectpath","aspects120.jar","Program.java"});
+//  	assertTrue("Should have failed",cR.getFailMessages().size()>0);
+//  	assertTrue("Should have produced nice message",cR.getFailMessages().get(0).toString().indexOf("Unable to continue")!=-1);
+//  }
+ 
+}

weaver/src/org/aspectj/weaver/AdviceKind.java

 
 package org.aspectj.weaver;
 
-import java.io.DataInputStream;
 import java.io.IOException;
 
 import org.aspectj.util.TypeSafeEnum;
     	this.isCflow = isCflow;
     }
     
-    public static AdviceKind read(DataInputStream s) throws IOException {
+    public static AdviceKind read(VersionedDataInputStream s) throws IOException {
         int key = s.readByte();
         switch(key) {
             case 1: return Before;

weaver/src/org/aspectj/weaver/AjAttribute.java

 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 			throw new RuntimeException("sanity check");
 		}
 	}
-
-	public static AjAttribute read(String name, byte[] bytes, ISourceContext context,IMessageHandler msgHandler) {
+	
+	public static AjAttribute read(AjAttribute.WeaverVersionInfo v, String name, byte[] bytes, ISourceContext context,IMessageHandler msgHandler) {
 		try {
 			if (bytes == null) bytes = new byte[0];
-			DataInputStream s = new DataInputStream(new ByteArrayInputStream(bytes));
+			VersionedDataInputStream s = new VersionedDataInputStream(new ByteArrayInputStream(bytes));
+			s.setVersion(v);
 			if (name.equals(Aspect.AttributeName)) {
 				return new Aspect(PerClause.readPerClause(s, context));
 			} else if (name.equals(MethodDeclarationLineNumberAttribute.AttributeName)) {
 		// The user will get a warning for any org.aspectj.weaver attributes the weaver does
 		// not recognize.
 		
+		// When we don't know ... (i.e. pre 1.2.1)
+		public static short WEAVER_VERSION_MAJOR_UNKNOWN = 0;
+		public static short WEAVER_VERSION_MINOR_UNKNOWN = 0;
+		
+		
 		// These are the weaver major/minor numbers for AspectJ 1.2.1
-		private static short WEAVER_VERSION_MAJOR_AJ121 = 1;
-		private static short WEAVER_VERSION_MINOR_AJ121 = 0;
+		public static short WEAVER_VERSION_MAJOR_AJ121 = 1;
+		public static short WEAVER_VERSION_MINOR_AJ121 = 0;
+		
+		// These are the weaver major/minor numbers for AspectJ 1.5.0
+		public static short WEAVER_VERSION_MAJOR_AJ150 = 2;
+		public static short WEAVER_VERSION_MINOR_AJ150 = 0;
 		
 		// These are the weaver major/minor versions for *this* weaver
-		private static short CURRENT_VERSION_MAJOR      = WEAVER_VERSION_MAJOR_AJ121;
-		private static short CURRENT_VERSION_MINOR      = WEAVER_VERSION_MINOR_AJ121;
+		private static short CURRENT_VERSION_MAJOR      = WEAVER_VERSION_MAJOR_AJ150;
+		private static short CURRENT_VERSION_MINOR      = WEAVER_VERSION_MINOR_AJ150;
+		
+		public static final WeaverVersionInfo UNKNOWN = 
+			new WeaverVersionInfo(WEAVER_VERSION_MAJOR_UNKNOWN,WEAVER_VERSION_MINOR_UNKNOWN);
 		
 		// These are the versions read in from a particular class file.
 		private short major_version; 
 			s.writeShort(CURRENT_VERSION_MINOR);
 		}
 		
-		public static WeaverVersionInfo read(DataInputStream s) throws IOException {
+		public static WeaverVersionInfo read(VersionedDataInputStream s) throws IOException {
 			short major = s.readShort();
 			short minor = s.readShort();
-			return new WeaverVersionInfo(major,minor);
+			WeaverVersionInfo wvi = new WeaverVersionInfo(major,minor);
+//			s.setVersion(wvi);		
+			return wvi;
 		}
 		
 		public short getMajorVersion() {
 			FileUtil.writeIntArray(lineBreaks, s);
 		}
 		
-		public static SourceContextAttribute read(DataInputStream s) throws IOException {
+		public static SourceContextAttribute read(VersionedDataInputStream s) throws IOException {
 			return new SourceContextAttribute(s.readUTF(), FileUtil.readIntArray(s));
 		}
 		public int[] getLineBreaks() {
 			s.writeInt(lineNumber);
 		}
 		
-		public static MethodDeclarationLineNumberAttribute read(DataInputStream s) throws IOException {
+		public static MethodDeclarationLineNumberAttribute read(VersionedDataInputStream s) throws IOException {
 			return new MethodDeclarationLineNumberAttribute(s.readInt());
 		}
 
 			this.declaredExceptions = declaredExceptions;
 		}
 		
-		public static AdviceAttribute read(DataInputStream s, ISourceContext context) throws IOException {
+		public static AdviceAttribute read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 			AdviceKind kind = AdviceKind.read(s);
 			if (kind == AdviceKind.Around) {
 				return new AdviceAttribute(
 			return accessedMembers;
 		}
 
-		public static PrivilegedAttribute read(DataInputStream s, ISourceContext context) throws IOException {
+		public static PrivilegedAttribute read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 			return new PrivilegedAttribute(ResolvedMember.readResolvedMemberArray(s, context));
 		}
 	}	
 			s.writeBoolean(weaveBody);
 		}		
 
-		public static EffectiveSignatureAttribute read(DataInputStream s, ISourceContext context) throws IOException {
+		public static EffectiveSignatureAttribute read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 			return new EffectiveSignatureAttribute(
 					ResolvedMember.readResolvedMember(s, context),
 					Shadow.Kind.read(s),

weaver/src/org/aspectj/weaver/ResolvedPointcutDefinition.java

 
 package org.aspectj.weaver;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 		pointcut.write(s);
 	}
 	
-	public static ResolvedPointcutDefinition read(DataInputStream s, ISourceContext context) throws IOException {
+	public static ResolvedPointcutDefinition read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		return new ResolvedPointcutDefinition(
 			TypeX.read(s),
 			s.readInt(),

weaver/src/org/aspectj/weaver/VersionedDataInputStream.java

+/* *******************************************************************
+ * Copyright (c) 2005 IBM
+ * 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: 
+ *     Andy Clement           initial implementation
+ * ******************************************************************/
+
+package org.aspectj.weaver;	
+
+import java.io.DataInputStream;
+import java.io.InputStream;
+
+import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
+
+/**
+ * Lightweight subclass of DataInputStream that knows what version of the weaver was used to construct the data in it.
+ */
+public class VersionedDataInputStream extends DataInputStream {
+	private WeaverVersionInfo version = new WeaverVersionInfo();// assume we are the latest unless something tells us otherwise...
+	public VersionedDataInputStream(InputStream is) { super(is); }
+	
+	public int getMajorVersion() { return version.getMajorVersion(); }
+	public int getMinorVersion() { return version.getMinorVersion(); }
+	
+	public void setVersion(WeaverVersionInfo version) { this.version = version; }
+}

weaver/src/org/aspectj/weaver/WeaverStateInfo.java

 	private static final byte REWEAVABLE_BIT             = 1<<4;
 	private static final byte REWEAVABLE_COMPRESSION_BIT = 1<<5;
 	
-	public static final WeaverStateInfo read(DataInputStream s, ISourceContext context) throws IOException {
+	public static final WeaverStateInfo read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte b = s.readByte();
 		
 		boolean isReweavable = ((b&REWEAVABLE_BIT)!=0);

weaver/src/org/aspectj/weaver/bcel/BcelAttributes.java

 import org.aspectj.apache.bcel.generic.ConstantPoolGen;
 import org.aspectj.bridge.IMessageHandler;
 import org.aspectj.weaver.AjAttribute;
+import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
 
 
 // this is a class o' static methods for reading attributes.  It's pretty much a bridge from 
 // bcel to AjAttribute.
 class BcelAttributes {
 
-	public static List readAjAttributes(Attribute[] as, ISourceContext context,IMessageHandler msgHandler) {
+	public static List readAjAttributes(String classname,Attribute[] as, ISourceContext context,IMessageHandler msgHandler) {
 		List l = new ArrayList();
+		AjAttribute.WeaverVersionInfo version = new WeaverVersionInfo();
 		for (int i = as.length - 1; i >= 0; i--) {
 			Attribute a = as[i];
 			if (a instanceof Unknown) {
 				Unknown u = (Unknown) a;
 				String name = u.getName();
 				if (name.startsWith(AjAttribute.AttributePrefix)) {
-					AjAttribute attr = AjAttribute.read(name, u.getBytes(), context,msgHandler);
+					AjAttribute attr = AjAttribute.read(version,name,u.getBytes(),context,msgHandler); 
+					if (attr!=null && attr instanceof AjAttribute.WeaverVersionInfo) {
+						version = (AjAttribute.WeaverVersionInfo)attr;
+						
+						// Do a version check, this weaver can't process versions 
+						// from a future AspectJ (where the major number has changed)
+						if (version.getMajorVersion() > WeaverVersionInfo.getCurrentWeaverMajorVersion()) {
+							throw new BCException("Unable to continue, this version of AspectJ supports classes built with weaver version "+
+									WeaverVersionInfo.toCurrentVersionString()+" but the class "+classname+" is version "+version.toString());
+						}
+					}
 					if (attr!=null) l.add(attr);
 				}
 			}

weaver/src/org/aspectj/weaver/bcel/BcelField.java

 	
 	private void unpackAttributes(World world) {
 		Attribute[] attrs = field.getAttributes();
-		List as = BcelAttributes.readAjAttributes(attrs, getSourceContext(world),world.getMessageHandler());
+		List as = BcelAttributes.readAjAttributes(getDeclaringType().getClassName(),attrs, getSourceContext(world),world.getMessageHandler());
 		for (Iterator iter = as.iterator(); iter.hasNext();) {
 			AjAttribute a = (AjAttribute) iter.next();
 			if (a instanceof AjAttribute.AjSynthetic) {

weaver/src/org/aspectj/weaver/bcel/BcelMethod.java

 	}
 
 	private void unpackAjAttributes(World world) {
-		List as = BcelAttributes.readAjAttributes(method.getAttributes(), getSourceContext(world),world.getMessageHandler());
+		List as = BcelAttributes.readAjAttributes(getDeclaringType().getClassName(),method.getAttributes(), getSourceContext(world),world.getMessageHandler());
 		//System.out.println("unpack: " + this + ", " + as);
 		for (Iterator iter = as.iterator(); iter.hasNext();) {
 			AjAttribute a = (AjAttribute) iter.next();

weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java

 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
 import org.aspectj.weaver.WeaverStateInfo;
-import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
 import org.aspectj.weaver.patterns.PerClause;
 
 // ??? exposed for testing
 		List pointcuts = new ArrayList();
 		typeMungers = new ArrayList();
 		declares = new ArrayList();
-		List l = BcelAttributes.readAjAttributes(javaClass.getAttributes(), getResolvedTypeX().getSourceContext(),getResolvedTypeX().getWorld().getMessageHandler());
+		List l = BcelAttributes.readAjAttributes(javaClass.getClassName(),javaClass.getAttributes(), getResolvedTypeX().getSourceContext(),getResolvedTypeX().getWorld().getMessageHandler());
 		for (Iterator iter = l.iterator(); iter.hasNext();) {
 			AjAttribute a = (AjAttribute) iter.next();
 			//System.err.println("unpacking: " + this + " and " + a);
 					((BcelSourceContext)getResolvedTypeX().getSourceContext()).addAttributeInfo((AjAttribute.SourceContextAttribute)a);
 				}
 			} else if (a instanceof AjAttribute.WeaverVersionInfo) {
-				wvInfo = (AjAttribute.WeaverVersionInfo)a;
-				if (wvInfo.getMajorVersion() > WeaverVersionInfo.getCurrentWeaverMajorVersion()) {
-					// The class file containing this attribute was created by a version of AspectJ that
-					// added some behavior that 'this' version of AspectJ doesn't understand.  And the
-					// class file contains changes that mean 'this' version of AspectJ cannot continue.
-					throw new BCException("Unable to continue, this version of AspectJ supports classes built with weaver version "+
-							WeaverVersionInfo.toCurrentVersionString()+" but the class "+ javaClass.getClassName()+" is version "+wvInfo.toString());
-				}
+				wvInfo = (AjAttribute.WeaverVersionInfo)a; // Set the weaver version used to build this type
 			} else {
 				throw new BCException("bad attribute " + a);
 			}
 		}
 		this.pointcuts = (ResolvedPointcutDefinition[]) 
 			pointcuts.toArray(new ResolvedPointcutDefinition[pointcuts.size()]);
+		// Test isn't quite right, leaving this out for now...
+//		if (isAspect() && wvInfo.getMajorVersion() == WeaverVersionInfo.UNKNOWN.getMajorVersion()) {
+//			throw new BCException("Unable to continue, this version of AspectJ cannot use aspects as input that were built "+
+//					"with an AspectJ earlier than version 1.2.1.  Please rebuild class: "+javaClass.getClassName());
+//		}
+		
 //		this.typeMungers = (BcelTypeMunger[]) 
 //			typeMungers.toArray(new BcelTypeMunger[typeMungers.size()]);
 //		this.declares = (Declare[])

weaver/src/org/aspectj/weaver/bcel/LazyMethodGen.java

 		if (enclosingClass != null && enclosingClass.getType() != null) {
 			context = enclosingClass.getType().getSourceContext();
 		}
-		List as = BcelAttributes.readAjAttributes(attributes, context,null);
+		List as = BcelAttributes.readAjAttributes(getClassName(),attributes, context,null);
 		if (! as.isEmpty()) {
 			out.println("    " + as.get(0)); // XXX assuming exactly one attribute, munger...
 		}

weaver/src/org/aspectj/weaver/patterns/AndAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.AnnotatedElement;
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 /**
 		return this;
 	}
 	
-	public static AnnotationTypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern p = new AndAnnotationTypePattern(
 				AnnotationTypePattern.read(s,context),
 				AnnotationTypePattern.read(s,context));

weaver/src/org/aspectj/weaver/patterns/AndPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Test;
 
 public class AndPointcut extends Pointcut {
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AndPointcut ret = new AndPointcut(Pointcut.read(s, context), Pointcut.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/AndTypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 /**
  * left && right
 		writeLocation(s);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePattern ret = new AndTypePattern(TypePattern.read(s, context), TypePattern.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/AnnotationPatternList.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.List;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 /**
         return result;
     }
     
-	public static AnnotationPatternList read(DataInputStream s, ISourceContext context) throws IOException  {
+	public static AnnotationPatternList read(VersionedDataInputStream s, ISourceContext context) throws IOException  {
 		short len = s.readShort();
 		AnnotationTypePattern[] arguments = new AnnotationTypePattern[len];
 		for (int i=0; i<len; i++) {

weaver/src/org/aspectj/weaver/patterns/AnnotationPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 import org.aspectj.weaver.ast.Var;
 		writeLocation(s);
 	}
 
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern type = AnnotationTypePattern.read(s, context);
 		AnnotationPointcut ret = new AnnotationPointcut((ExactAnnotationTypePattern)type);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/AnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.IntMap;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 public abstract class AnnotationTypePattern extends PatternNode {
 	public static final byte ANY_KEY = 7;
 	public static final byte WILD = 8;
 
-	public static AnnotationTypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte key = s.readByte();
 		switch(key) {
 			case EXACT: return ExactAnnotationTypePattern.read(s, context);

weaver/src/org/aspectj/weaver/patterns/ArgsAnnotationPointcut.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationPatternList annotationPatternList = AnnotationPatternList.read(s,context);
 		ArgsAnnotationPointcut ret = new ArgsAnnotationPointcut(annotationPatternList);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/ArgsPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		ArgsPointcut ret = new ArgsPointcut(TypePatternList.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/BindingAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 
 		writeLocation(s);
 	}	
 	
-	public static AnnotationTypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte version = s.readByte();
 		if (version > VERSION) {
 			throw new BCException("BindingAnnotationTypePattern was written by a more recent version of AspectJ");

weaver/src/org/aspectj/weaver/patterns/BindingTypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 public class BindingTypePattern extends ExactTypePattern implements BindingPattern {
 	private int formalIndex;
 		writeLocation(out);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePattern ret = new BindingTypePattern(TypeX.read(s), s.readShort(), s.readBoolean());
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/CflowPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 import org.aspectj.weaver.ast.Test;
 		FileUtil.writeIntArray(freeVars, s);
 		writeLocation(s);
 	}
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 
 		CflowPointcut ret = new CflowPointcut(Pointcut.read(s, context), s.readBoolean(), FileUtil.readIntArray(s));
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/Declare.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 public abstract class Declare extends PatternNode {
 	public static final byte ERROR_OR_WARNING = 1;
 	public static final byte SOFT = 3;
 	public static final byte DOMINATES = 4;
 
-	public static Declare read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte kind = s.readByte();
 		switch (kind) {
 			case ERROR_OR_WARNING:

weaver/src/org/aspectj/weaver/patterns/DeclareErrorOrWarning.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 public class DeclareErrorOrWarning extends Declare {
 	private boolean isError;
 		writeLocation(s);
 	}
 
-	public static Declare read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Declare ret = new DeclareErrorOrWarning(
 			s.readBoolean(),
 			Pointcut.read(s, context),

weaver/src/org/aspectj/weaver/patterns/DeclareParents.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 
 		writeLocation(s);
 	}
 
-	public static Declare read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Declare ret = new DeclareParents(TypePattern.read(s, context), TypePatternList.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/DeclarePrecedence.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.List;
 import org.aspectj.bridge.IMessage;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 
 public class DeclarePrecedence extends Declare {
 		writeLocation(s);
 	}
 
-	public static Declare read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Declare ret = new DeclarePrecedence(TypePatternList.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/DeclareSoft.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 
 public class DeclareSoft extends Declare {
 		writeLocation(s);
 	}
 
-	public static Declare read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Declare ret = new DeclareSoft(
 			TypePattern.read(s, context),
 			Pointcut.read(s, context)

weaver/src/org/aspectj/weaver/patterns/ExactAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 
 		writeLocation(s);
 	}
 
-	public static AnnotationTypePattern read(DataInputStream s,ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s,ISourceContext context) throws IOException {
 		AnnotationTypePattern ret;
 		byte version = s.readByte();
 		if (version > VERSION) {

weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java

 import java.util.Map;
 
 import org.aspectj.util.FuzzyBoolean;
+import org.aspectj.weaver.AjAttribute;
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 public class ExactTypePattern extends TypePattern {
 	protected TypeX type;
 		writeLocation(out);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
+		if (s.getMajorVersion()>=AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
+			return readTypePattern150(s,context);
+		} else {
+			return readTypePatternOldStyle(s,context);
+	    }
+    }
+	
+	public static TypePattern readTypePattern150(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte version = s.readByte();
 		if (version > EXACT_VERSION) throw new BCException("ExactTypePattern was written by a more recent version of AspectJ");
 		TypePattern ret = new ExactTypePattern(TypeX.read(s), s.readBoolean(), s.readBoolean());
 		return ret;
 	}
 
-    public String toString() {
+	public static TypePattern readTypePatternOldStyle(DataInputStream s, ISourceContext context) throws IOException {
+		TypePattern ret = new ExactTypePattern(TypeX.read(s), s.readBoolean(),false);
+		ret.readLocation(context, s);
+		return ret;
+	}
+
+	public String toString() {
 		StringBuffer buff = new StringBuffer();
 		if (annotationPattern != AnnotationTypePattern.ANY) {
 			buff.append('(');

weaver/src/org/aspectj/weaver/patterns/HandlerPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 import org.aspectj.weaver.internal.tools.PointcutExpressionImpl;
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		HandlerPointcut ret = new HandlerPointcut(TypePattern.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/IfPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Expr;
 import org.aspectj.weaver.ast.Literal;
 		s.writeByte(extraParameterFlags);
 		writeLocation(s);
 	}
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		IfPointcut ret = new IfPointcut(ResolvedMember.readResolvedMember(s, context), s.readByte());
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.HashSet;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Shadow.Kind kind = Shadow.Kind.read(s);
 		SignaturePattern sig = SignaturePattern.read(s, context);
 		KindedPointcut ret = new KindedPointcut(kind, sig);

weaver/src/org/aspectj/weaver/patterns/ModifiersPattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.aspectj.weaver.VersionedDataInputStream;
+
 public class ModifiersPattern extends PatternNode {
 	private int requiredModifiers;
 	private int forbiddenModifiers;
 	}
 	
 
-	public static ModifiersPattern read(DataInputStream s) throws IOException {
+	public static ModifiersPattern read(VersionedDataInputStream s) throws IOException {
 		int requiredModifiers = s.readShort();
 		int forbiddenModifiers = s.readShort();
 		if (requiredModifiers == 0 && forbiddenModifiers == 0) return ANY;

weaver/src/org/aspectj/weaver/patterns/NamePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import org.aspectj.weaver.VersionedDataInputStream;
+
 public class NamePattern extends PatternNode {
 	char[] pattern;
 	int starCount = 0;
 		out.writeUTF(new String(pattern));
 	}
 	
-	public static NamePattern read(DataInputStream in) throws IOException {
+	public static NamePattern read(VersionedDataInputStream in) throws IOException {
 		String s = in.readUTF();
 		if (s.length() == 0) return ELLIPSIS;
 		return new NamePattern(s);

weaver/src/org/aspectj/weaver/patterns/NotAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.AnnotatedElement;
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 public class NotAnnotationTypePattern extends AnnotationTypePattern {
 		writeLocation(s);
 	}
 
-	public static AnnotationTypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern ret = new NotAnnotationTypePattern(AnnotationTypePattern.read(s,context));
 		ret.readLocation(context,s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/NotPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Test;
 
 public class NotPointcut extends Pointcut {
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		NotPointcut ret = new NotPointcut(Pointcut.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/NotTypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 /**
  * !TypePattern
 		writeLocation(s);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePattern ret = new NotTypePattern(TypePattern.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/OrAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.AnnotatedElement;
 import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 public class OrAnnotationTypePattern extends AnnotationTypePattern {
 		return this;
 	}
 
-	public static AnnotationTypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern p = new OrAnnotationTypePattern(
 				AnnotationTypePattern.read(s,context),
 				AnnotationTypePattern.read(s,context));

weaver/src/org/aspectj/weaver/patterns/OrPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Test;
 
 public class OrPointcut extends Pointcut {
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		OrPointcut ret = new OrPointcut(Pointcut.read(s, context), Pointcut.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/OrTypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.util.FuzzyBoolean;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 /**
  * left || right
 		writeLocation(s);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePattern ret = new OrTypePattern(TypePattern.read(s, context), TypePattern.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/PerCflow.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 import org.aspectj.weaver.ast.Expr;
 import org.aspectj.weaver.ast.Test;
     	writeLocation(s);
     }
     
-	public static PerClause readPerClause(DataInputStream s, ISourceContext context) throws IOException {
+	public static PerClause readPerClause(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		PerCflow ret = new PerCflow(Pointcut.read(s, context), s.readBoolean());
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/PerClause.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.IOException;
 
 import org.aspectj.util.TypeSafeEnum;
 public abstract class PerClause extends Pointcut {
 	protected ResolvedTypeX inAspect;
 
-	public static PerClause readPerClause(DataInputStream s, ISourceContext context) throws IOException {
+	public static PerClause readPerClause(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Kind kind = Kind.read(s);
 		if (kind == SINGLETON) return PerSingleton.readPerClause(s, context);
 		else if (kind == PERCFLOW) return PerCflow.readPerClause(s, context);
 	public static class Kind extends TypeSafeEnum {
         public Kind(String name, int key) { super(name, key); }
         
-        public static Kind read(DataInputStream s) throws IOException {
+        public static Kind read(VersionedDataInputStream s) throws IOException {
             int key = s.readByte();
             switch(key) {
                 case 1: return SINGLETON;

weaver/src/org/aspectj/weaver/patterns/PerFromSuper.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.Set;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Test;
 
     	writeLocation(s);
     }
     
-	public static PerClause readPerClause(DataInputStream s, ISourceContext context) throws IOException {
+	public static PerClause readPerClause(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		PerFromSuper ret = new PerFromSuper(Kind.read(s));
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/PerObject.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.HashSet;
 import org.aspectj.weaver.ResolvedTypeMunger;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 import org.aspectj.weaver.ast.Expr;
 import org.aspectj.weaver.ast.Test;
     	writeLocation(s);
     }
     
-	public static PerClause readPerClause(DataInputStream s, ISourceContext context) throws IOException {
+	public static PerClause readPerClause(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		PerClause ret = new PerObject(Pointcut.read(s, context), s.readBoolean());
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/PerSingleton.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.Set;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Expr;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
     	writeLocation(s);
     }
     
-	public static PerClause readPerClause(DataInputStream s, ISourceContext context) throws IOException {
+	public static PerClause readPerClause(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		PerSingleton ret = new PerSingleton();
 		ret.readLocation(context, s);
 		return ret;

weaver/src/org/aspectj/weaver/patterns/Pointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 
 	//XXX currently it's unused  we're keeping it around as a stub
 	public void postRead(ResolvedTypeX enclosingType) {}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte kind = s.readByte();
 		Pointcut ret;
 		

weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Test;
 
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypeX onType = null;
 		if (s.readBoolean()) {
 			onType = TypeX.read(s);

weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import org.aspectj.lang.reflect.ConstructorSignature;
 import org.aspectj.lang.reflect.FieldSignature;
 import org.aspectj.lang.reflect.MethodSignature;
+import org.aspectj.weaver.AjAttribute;
 import org.aspectj.weaver.Constants;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.Member;
 import org.aspectj.weaver.ResolvedMember;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 
 		writeLocation(s);
 	}
 
-	public static SignaturePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static SignaturePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		Member.Kind kind = Member.Kind.read(s);
 		ModifiersPattern modifiers = ModifiersPattern.read(s);
 		TypePattern returnType = TypePattern.read(s, context);
 		NamePattern name = NamePattern.read(s);
 		TypePatternList parameterTypes = TypePatternList.read(s, context);
 		ThrowsPattern throwsPattern = ThrowsPattern.read(s, context);
-		AnnotationTypePattern annotationPattern = AnnotationTypePattern.read(s,context);
+		
+		AnnotationTypePattern annotationPattern = AnnotationTypePattern.ANY;
+		
+		if (s.getMajorVersion()>=AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
+		  annotationPattern = AnnotationTypePattern.read(s,context);
+		}
+
 		SignaturePattern ret = new SignaturePattern(kind, modifiers, returnType, declaringType,
 					name, parameterTypes, throwsPattern,annotationPattern);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/ThisOrTargetAnnotationPointcut.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 	    boolean isThis = s.readBoolean();
 		AnnotationTypePattern type = AnnotationTypePattern.read(s, context);
 		ThisOrTargetAnnotationPointcut ret = new ThisOrTargetAnnotationPointcut(isThis,(ExactAnnotationTypePattern)type);

weaver/src/org/aspectj/weaver/patterns/ThisOrTargetPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		type.write(s);
 		writeLocation(s);
 	}
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		boolean isThis = s.readBoolean();
 		TypePattern type = TypePattern.read(s, context);
 		ThisOrTargetPointcut ret = new ThisOrTargetPointcut(isThis, type);

weaver/src/org/aspectj/weaver/patterns/ThrowsPattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 
 		return false;
 	}
 
-	public static ThrowsPattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static ThrowsPattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePatternList required = TypePatternList.read(s, context);
 		TypePatternList forbidden = TypePatternList.read(s, context);
 		if (required.size() == 0 && forbidden.size() == 0) return ANY;

weaver/src/org/aspectj/weaver/patterns/TypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.Iterator;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 /**
 	public static final byte AND = 8;
 	public static final byte NO_KEY = 9;
 
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		byte key = s.readByte();
 		switch(key) {
 			case WILD: return WildTypePattern.read(s, context);

weaver/src/org/aspectj/weaver/patterns/TypePatternList.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 
 public class TypePatternList extends PatternNode {
 	private TypePattern[] typePatterns;
     }
     
 
-	public static TypePatternList read(DataInputStream s, ISourceContext context) throws IOException  {
+	public static TypePatternList read(VersionedDataInputStream s, ISourceContext context) throws IOException  {
 		short len = s.readShort();
 		TypePattern[] arguments = new TypePattern[len];
 		for (int i=0; i<len; i++) {

weaver/src/org/aspectj/weaver/patterns/WildAnnotationTypePattern.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.World;
 
 		writeLocation(s);
 	}
 
-	public static AnnotationTypePattern read(DataInputStream s,ISourceContext context) throws IOException {
+	public static AnnotationTypePattern read(VersionedDataInputStream s,ISourceContext context) throws IOException {
 		AnnotationTypePattern ret;
 		byte version = s.readByte();
 		if (version > VERSION) {

weaver/src/org/aspectj/weaver/patterns/WildTypePattern.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.bridge.MessageUtil;
 import org.aspectj.util.FileUtil;
 import org.aspectj.util.FuzzyBoolean;
+import org.aspectj.weaver.AjAttribute;
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.ISourceContext;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 
 //XXX need to use dim in matching
 		annotationPattern.write(s);
 	}
 	
-	public static TypePattern read(DataInputStream s, ISourceContext context) throws IOException {
-		byte version = s.readByte();
-		if (version > VERSION) {
-			throw new BCException("WildTypePattern was written by a more recent version of AspectJ, cannot read");
-		}
+	public static TypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
+		if (s.getMajorVersion()>=AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
+			return readTypePattern150(s,context);
+		} else {
+			return readTypePatternOldStyle(s,context);
+	    }
+    }
+
+    public static TypePattern readTypePattern150(VersionedDataInputStream s, ISourceContext context) throws IOException {
+	  byte version = s.readByte();
+	  if (version > VERSION) {
+		throw new BCException("WildTypePattern was written by a more recent version of AspectJ, cannot read");
+	  }
+	  int len = s.readShort();
+	  NamePattern[] namePatterns = new NamePattern[len];
+	  for (int i=0; i < len; i++) {
+		namePatterns[i] = NamePattern.read(s);
+	  }
+	  boolean includeSubtypes = s.readBoolean();
+	  int dim = s.readInt();
+	  boolean varArg = s.readBoolean();
+	  WildTypePattern ret = new WildTypePattern(namePatterns, includeSubtypes, dim, varArg);
+	  ret.knownMatches = FileUtil.readStringArray(s);
+	  ret.importedPrefixes = FileUtil.readStringArray(s);
+	  ret.readLocation(context, s);
+	  ret.setAnnotationTypePattern(AnnotationTypePattern.read(s,context));
+	  return ret;
+	}
+    
+	public static TypePattern readTypePatternOldStyle(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		int len = s.readShort();
 		NamePattern[] namePatterns = new NamePattern[len];
 		for (int i=0; i < len; i++) {
 		}
 		boolean includeSubtypes = s.readBoolean();
 		int dim = s.readInt();
-		boolean varArg = s.readBoolean();
-		WildTypePattern ret = new WildTypePattern(namePatterns, includeSubtypes, dim,varArg);
+		WildTypePattern ret = new WildTypePattern(namePatterns, includeSubtypes, dim, false);
 		ret.knownMatches = FileUtil.readStringArray(s);
 		ret.importedPrefixes = FileUtil.readStringArray(s);
 		ret.readLocation(context, s);
-		ret.setAnnotationTypePattern(AnnotationTypePattern.read(s,context));
 		return ret;
 	}
 

weaver/src/org/aspectj/weaver/patterns/WithinAnnotationPointcut.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		writeLocation(s);
 	}
 
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern type = AnnotationTypePattern.read(s, context);
 		WithinAnnotationPointcut ret = new WithinAnnotationPointcut((ExactAnnotationTypePattern)type);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/WithinCodeAnnotationPointcut.java

  * ******************************************************************/
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.ShadowMunger;
 import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 import org.aspectj.weaver.ast.Var;
 		writeLocation(s);
 	}
 
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		AnnotationTypePattern type = AnnotationTypePattern.read(s, context);
 		WithinCodeAnnotationPointcut ret = new WithinCodeAnnotationPointcut((ExactAnnotationTypePattern)type);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.WeaverMessages;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 		typePattern.write(s);
 		writeLocation(s);
 	}
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		TypePattern type = TypePattern.read(s, context);
 		WithinPointcut ret = new WithinPointcut(type);
 		ret.readLocation(context, s);

weaver/src/org/aspectj/weaver/patterns/WithincodePointcut.java

 
 package org.aspectj.weaver.patterns;
 
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Member;
 import org.aspectj.weaver.IntMap;
 import org.aspectj.weaver.ResolvedTypeX;
 import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 
 		writeLocation(s);
 	}
 	
-	public static Pointcut read(DataInputStream s, ISourceContext context) throws IOException {
+	public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException {
 		WithincodePointcut ret = new WithincodePointcut(SignaturePattern.read(s, context));
 		ret.readLocation(context, s);
 		return ret;

weaver/testsrc/org/aspectj/weaver/bcel/PatternWeaveTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		Pointcut newP = Pointcut.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/bcel/PointcutResidueTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		Pointcut newP = Pointcut.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/AndOrNotTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		Pointcut newP = Pointcut.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/DeclareErrorOrWarningTestCase.java

 
 import java.io.*;
 
+import org.aspectj.weaver.VersionedDataInputStream;
+
 import junit.framework.TestCase;
 
 public class DeclareErrorOrWarningTestCase extends TestCase {
 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		Declare newDeclare = Declare.read(in, null);
 		
 		assertEquals("write/read", declare, newDeclare);	

weaver/testsrc/org/aspectj/weaver/patterns/ModifiersPatternTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		ModifiersPattern newP = ModifiersPattern.read(in);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/NamePatternTestCase.java

 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import org.aspectj.weaver.VersionedDataInputStream;
+
 import junit.framework.TestCase;
 
 /**
 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		NamePattern newP = NamePattern.read(in);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		SignaturePattern newP = SignaturePattern.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/TypePatternListTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		TypePatternList newP = TypePatternList.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/TypePatternTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		TypePattern newP = TypePattern.read(in, null);
 		
 		assertEquals("write/read", p, newP);	

weaver/testsrc/org/aspectj/weaver/patterns/WithinTestCase.java

 		out.close();
 		
 		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
-		DataInputStream in = new DataInputStream(bi);
+		VersionedDataInputStream in = new VersionedDataInputStream(bi);
 		Pointcut newP = Pointcut.read(in, null);
 		
 		assertEquals("write/read", p, newP);