last patches for 141730

4 files changed, 696 insertions, 40 deletions

diff --git a/tests/src/org/aspectj/systemtest/ajc150/AnnotationBinding.java b/tests/src/org/aspectj/systemtest/ajc150/AnnotationBinding.java
index 8766bfa98..99c285158 100644
--- a/tests/src/org/aspectj/systemtest/ajc150/AnnotationBinding.java
+++ b/tests/src/org/aspectj/systemtest/ajc150/AnnotationBinding.java
@@ -330,7 +330,8 @@ public class AnnotationBinding extends XMLBasedAjcTestCase {
 			Relationship rel = (Relationship)l.get(0);
 			assertTrue("Should have 1 target but has "+rel.getTargets().size(),rel.getTargets().size()==1);
 			String tgt = (String)rel.getTargets().get(0);
-			assertTrue("Should point to line 10 but doesnt: "+tgt,tgt.indexOf("|10|")!=-1);
+			int lineNumber = AsmManager.getDefault().getHandleProvider().getLineNumberForHandle(tgt);
+			assertTrue("Should point to line 10 but doesnt: "+lineNumber,lineNumber == 10);
 	  	}
   }  
  
@@ -360,7 +361,9 @@ public class AnnotationBinding extends XMLBasedAjcTestCase {
 			Relationship rel = (Relationship)l.get(0);
 			assertTrue("Should have 1 target but has "+rel.getTargets().size(),rel.getTargets().size()==1);
 			String tgt = (String)rel.getTargets().get(0);
-			assertTrue("Should point to line 10 but doesnt: "+tgt,tgt.indexOf("|10|")!=-1);
+			int lineNumber = AsmManager.getDefault().getHandleProvider().getLineNumberForHandle(tgt);
+			assertTrue("Should point to line 10 but doesnt: "+lineNumber,lineNumber == 10);
+
 	  	}
   }  
   
@@ -390,7 +393,9 @@ public class AnnotationBinding extends XMLBasedAjcTestCase {
 			Relationship rel = (Relationship)l.get(0);
 			assertTrue("Should have 1 target but has "+rel.getTargets().size(),rel.getTargets().size()==1);
 			String tgt = (String)rel.getTargets().get(0);
-			assertTrue("Should point to line 10 but doesnt: "+tgt,tgt.indexOf("|10|")!=-1);
+			int lineNumber = AsmManager.getDefault().getHandleProvider().getLineNumberForHandle(tgt);
+			assertTrue("Should point to line 10 but doesnt: "+lineNumber,lineNumber == 10);
+
 	  	}
   }  
   
diff --git a/tests/src/org/aspectj/systemtest/ajc153/AllTestsAspectJ153.java b/tests/src/org/aspectj/systemtest/ajc153/AllTestsAspectJ153.java
index 46aabab95..8bc30d5d2 100644
--- a/tests/src/org/aspectj/systemtest/ajc153/AllTestsAspectJ153.java
+++ b/tests/src/org/aspectj/systemtest/ajc153/AllTestsAspectJ153.java
@@ -19,6 +19,7 @@ public class AllTestsAspectJ153 {
 		TestSuite suite = new TestSuite("AspectJ 1.5.3 tests");
 		//$JUnit-BEGIN$
 		suite.addTest(Ajc153Tests.suite());
+		suite.addTest(JDTLikeHandleProviderTests.suite());
         //$JUnit-END$
 		return suite;
 	}
diff --git a/tests/src/org/aspectj/systemtest/ajc153/JDTLikeHandleProviderTests.java b/tests/src/org/aspectj/systemtest/ajc153/JDTLikeHandleProviderTests.java
new file mode 100644
index 000000000..a56036b10
--- /dev/null
+++ b/tests/src/org/aspectj/systemtest/ajc153/JDTLikeHandleProviderTests.java
@@ -0,0 +1,506 @@
+/********************************************************************
+ * Copyright (c) 2006 Contributors. All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: IBM Corporation - initial API and implementation 
+ * 				 Helen Hawkins   - initial version
+ *******************************************************************/
+package org.aspectj.systemtest.ajc153;
+
+import java.io.File;
+import java.util.Iterator;
+import java.util.List;
+
+import junit.framework.Test;
+
+import org.aspectj.asm.AsmManager;
+import org.aspectj.asm.IElementHandleProvider;
+import org.aspectj.asm.IHierarchy;
+import org.aspectj.asm.IProgramElement;
+import org.aspectj.asm.internal.JDTLikeHandleProvider;
+import org.aspectj.testing.XMLBasedAjcTestCase;
+
+public class JDTLikeHandleProviderTests extends XMLBasedAjcTestCase {
+
+	IElementHandleProvider handleProvider;
+	
+	protected void setUp() throws Exception {
+		super.setUp();
+		handleProvider = AsmManager.getDefault().getHandleProvider();
+		AsmManager.getDefault().setHandleProvider(new JDTLikeHandleProvider());
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		AsmManager.getDefault().setHandleProvider(handleProvider);
+	}
+	
+	public void testMoreThanOneNamedPointcut() {
+		runTest("More than one named pointcut");
+	}
+
+	public void testAspectHandle() {
+		runTest("aspect handle");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement pe = top.findElementForType("pkg", "A1");
+		String expected = "<pkg*A1.aj}A1";
+		String found = pe.getHandleIdentifier();
+		assertEquals("handleIdentifier - expected " + expected + ", but found "
+				+ found, expected, found);
+	}
+
+	public void testAdviceHandle() {
+		runTest("advice handle");
+		compareHandles(IProgramElement.Kind.ADVICE,
+				"before(): <anonymous pointcut>",
+				"<pkg*A2.aj}A2&before");
+	}
+
+	public void testPointcutHandle() {
+		runTest("pointcut handle");
+		compareHandles(IProgramElement.Kind.POINTCUT,
+				"p()",
+				"<pkg*A4.aj}A4+p");
+	}
+	
+	public void testGetIPEWithAspectHandle() {
+		runTest("get IProgramElement with aspect handle");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		String handle = "<pkg*A1.aj}A1";
+		IProgramElement ipe = top.getElement(handle);
+		assertNotNull("should have found ipe with handle " + handle, ipe);
+		IProgramElement ipe2 = top.getElement(handle);
+		assertEquals("should be the same IPE",ipe,ipe2);
+	}
+	
+	public void testAdviceHandleWithCrossCutting() {
+		runTest("advice handle with crosscutting");
+		compareHandles(IProgramElement.Kind.ADVICE,
+				"before(): <anonymous pointcut>",
+				"<pkg*A3.aj}A3&before");
+	}
+
+	public void testPointcutHandleWithArgs() {
+		runTest("pointcut handle with args");
+		compareHandles(IProgramElement.Kind.POINTCUT,
+				"p(java.lang.Integer)",
+				"*A6.aj}A6+p+QInteger;");
+	}
+	
+	public void testAdviceHandleWithArgs() {
+		runTest("advice handle with args");
+		compareHandles(IProgramElement.Kind.ADVICE,
+				"afterReturning(java.lang.Integer): p..",
+				"<pkg*A8.aj}A8&afterReturning&QInteger;");
+	}
+
+	public void testFieldITD() {
+		runTest("field itd handle");
+		compareHandles(IProgramElement.Kind.INTER_TYPE_FIELD,
+				"C.x",
+				"<pkg*A9.aj}A9)C.x");
+	}
+	
+	public void testMethodITD() {
+		runTest("method itd handle");
+		compareHandles(IProgramElement.Kind.INTER_TYPE_METHOD,
+				"C.method()",
+				"<pkg*A9.aj}A9)C.method");
+	}
+	
+	public void testMethodITDWithArgs() {
+		runTest("method itd with args handle");
+		compareHandles(IProgramElement.Kind.INTER_TYPE_METHOD,
+				"C.methodWithArgs(int)",
+				"<pkg*A9.aj}A9)C.methodWithArgs)I");
+	}
+	
+	public void testConstructorITDWithArgs() {
+		runTest("constructor itd with args");
+		compareHandles(IProgramElement.Kind.INTER_TYPE_CONSTRUCTOR,
+				"C.C(int,java.lang.String)",
+				"<pkg*A13.aj}A13)C.C)I)QString;");
+	}
+	
+	public void testDeclareParentsHandle() {
+		runTest("declare parents handle");
+		compareHandles(IProgramElement.Kind.DECLARE_PARENTS,
+				"declare parents: implements C2",
+				"<pkg*A7.aj}A7`declare parents");
+	}
+	
+	public void testTwoDeclareParents() {
+		runTest("two declare parents in same file");
+		compareHandles(IProgramElement.Kind.DECLARE_PARENTS,
+				"declare parents: extends C5",
+				"<pkg*A7.aj}A7`declare parents!2");
+	}
+	
+	public void testMethodCallHandle() {
+		runTest("method call handle");
+		compareHandles(IProgramElement.Kind.CODE,
+				"method-call(void pkg.C.m2())",
+				"<pkg*A10.aj[C~m1?method-call(void pkg.C.m2())");
+	}
+	
+	public void testDeclareAtType() {
+		// AJDT: =AJHandleProject/src<pkg*A.aj}A`declare \@type
+		runTest("declare @type");
+		compareHandles(IProgramElement.Kind.DECLARE_ANNOTATION_AT_TYPE,
+				"declare @type: pkg.C : @MyAnnotation",
+				"<pkg*A12.aj}A`declare @type");
+	}
+	
+	public void testDeclareAtField() {
+		// AJDT: =AJHandleProject/src<pkg*A.aj}A`declare \@field
+		runTest("declare @field");
+		compareHandles(IProgramElement.Kind.DECLARE_ANNOTATION_AT_FIELD,
+				"declare @field: int pkg.C.someField : @MyAnnotation",
+				"<pkg*A12.aj}A`declare @field!2");	
+	}
+	
+	public void testDeclareAtMethod() {
+		// AJDT: =AJHandleProject/src<pkg*A.aj}A`declare \@method
+		runTest("declare @method");
+		compareHandles(IProgramElement.Kind.DECLARE_ANNOTATION_AT_METHOD,
+				"declare @method: public void pkg.C.method1() : @MyAnnotation",
+				"<pkg*A12.aj}A`declare @method!3");	
+	}
+	
+	public void testDeclareAtConstructor() {
+		// AJDT: =AJHandleProject/src<pkg*A.aj}A`declare \@constructor
+		runTest("declare @constructor");
+		compareHandles(IProgramElement.Kind.DECLARE_ANNOTATION_AT_CONSTRUCTOR,
+				"declare @constructor: pkg.C.new() : @MyAnnotation",
+				"<pkg*A12.aj}A`declare @constructor!4");	
+	}
+	
+	
+	// what about 2 pieces of before advice with the same 
+	// signature and the same pointcut
+	public void testTwoPiecesOfAdviceWithSameSignatureAndPointcut() {
+		runTest("two pieces of advice with the same signature and pointcut");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement parent = top.findElementForLabel(top.getRoot(),
+				IProgramElement.Kind.ASPECT, "A5");
+		List children = parent.getChildren();
+		String handle1 = null;
+		String handle2 = null;
+		for (Iterator iter = children.iterator(); iter.hasNext();) {
+			IProgramElement element = (IProgramElement) iter.next();
+			if (element.getKind().equals(IProgramElement.Kind.ADVICE)) {
+				if (handle1 == null) {
+					handle1 = element.getHandleIdentifier();
+				} else {
+					handle2 = element.getHandleIdentifier();
+				}
+			}
+		}
+		String expected1 = "<pkg*A5.aj}A5&before";
+		String expected2 = "<pkg*A5.aj}A5&before!2";
+		boolean b = expected1.equals(handle1);
+		if (b) {
+			assertEquals("handleIdentifier - expected " + expected2 + ", but found "
+					+ handle2, expected2, handle2);
+		} else {
+			assertEquals("handleIdentifier - expected " + expected1 + ", but found "
+					+ handle2, expected1, handle2);
+			assertEquals("handleIdentifier - expected " + expected2 + ", but found "
+					+ handle1, expected2, handle1);
+		}
+	}
+	
+	public void testDeclareWarningHandle() {
+		runTest("declare warning handle");
+		compareHandles(IProgramElement.Kind.DECLARE_WARNING,
+				"declare warning: \"Illegal call.\"",
+				"<pkg*A11.aj}A11`declare warning");
+	}
+	
+	public void testTwoDeclareWarningHandles() {
+		runTest("two declare warning handles");
+		compareHandles(IProgramElement.Kind.DECLARE_WARNING,
+				"declare warning: \"blah\"",
+				"<pkg*A11.aj}A11`declare warning!2");
+	}
+	
+	// this is to ensure the logic for not including '1' in the count
+	// works correctly. We don't want a decw ipe with count 1 but we do
+	// want one with count 10.
+	public void testTenDeclareWarningHandles() {
+		runTest("ten declare warning handles");
+		compareHandles(IProgramElement.Kind.DECLARE_WARNING,
+				"declare warning: \"warning 1\"",
+				"*DeclareWarnings.aj}DeclareWarnings`declare warning");
+		compareHandles(IProgramElement.Kind.DECLARE_WARNING,
+				"declare warning: \"warning 10\"",
+				"*DeclareWarnings.aj}DeclareWarnings`declare warning!10");
+
+	}
+	
+	//---------- following tests ensure we produce the same handles as jdt -----//
+	//---------- (apart from the prefix)
+	
+	// NOTES: there is no ipe equivalent to a package fragment root or
+	//        
+	
+	public void testCompilationUnitSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java
+		runTest("compilation unit same as jdt");
+		compareHandles(IProgramElement.Kind.FILE_JAVA,
+				"Demo.java",
+				"<tjp{Demo.java");
+	}
+
+	public void testClassSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{C.java[C
+		runTest("class same as jdt");
+		compareHandles(IProgramElement.Kind.CLASS,
+				"C","<pkg{C.java[C");
+	}
+
+	public void testInterfaceSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{C.java[MyInterface
+		runTest("interface same as jdt");
+		compareHandles(IProgramElement.Kind.INTERFACE,
+				"MyInterface","<pkg{C.java[MyInterface");
+	}
+	
+	public void testConstructorSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{C.java[C~C
+		runTest("constructor same as jdt");
+		compareHandles(IProgramElement.Kind.CONSTRUCTOR,
+				"C()","<pkg{C.java[C~C");
+	}
+	
+	public void testConstructorWithArgsSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{C.java[C~C~QString;
+		runTest("constructor with args same as jdt");
+		compareHandles(IProgramElement.Kind.CONSTRUCTOR,
+				"C(java.lang.String)","<pkg{C.java[C~C~QString;");
+	}
+	
+//	public void testPackageDeclarationSameAsJDT() {
+//		// JDT: =TJP Example/src<tjp{Demo.java%tjp
+//		fail("package declaration isn't the same");
+//		runTest("package declaration same as jdt");
+//		compareHandles(IProgramElement.Kind.PACKAGE,
+//				"tjp",
+//				"<tjp{Demo.java%tjp");
+//	}	
+	
+	public void testImportDeclarationSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java#java.io.*
+		runTest("import declaration same as jdt");
+		compareHandles(IProgramElement.Kind.IMPORT_REFERENCE,
+				"java.io.*",
+				"<tjp{Demo.java#java.io.*");
+	}	
+	
+	public void testTypeSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo
+		runTest("type same as jdt");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement pe = top.findElementForType("tjp", "Demo");
+		String expected = "<tjp{Demo.java[Demo";
+		String found = pe.getHandleIdentifier();
+		assertEquals("handleIdentifier - expected " + expected + ", but found "
+				+ found, expected, found);
+	}	
+	
+	public void testFieldSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo^d
+		runTest("field same as jdt");
+		compareHandles(IProgramElement.Kind.FIELD,
+				"d",
+				"<tjp{Demo.java[Demo^d");
+	}	
+	public void testInitializationSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo|1 
+		// and =TJP Example/src<tjp{Demo.java[Demo|2
+		runTest("initialization same as jdt");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement parent = top.findElementForLabel(top.getRoot(),
+				IProgramElement.Kind.CLASS, "Demo");
+		List children = parent.getChildren();
+		String handle1 = null;
+		String handle2 = null;
+		for (Iterator iter = children.iterator(); iter.hasNext();) {
+			IProgramElement element = (IProgramElement) iter.next();
+			if (element.getKind().equals(IProgramElement.Kind.INITIALIZER)) {
+				if (handle1 == null) {
+					handle1 = element.getHandleIdentifier();
+				} else {
+					handle2 = element.getHandleIdentifier();
+				}
+			}
+		}
+		String expected1 = "<tjp{Demo.java[Demo|1";
+		String expected2 = "<tjp{Demo.java[Demo|2";
+		boolean b = expected1.equals(handle1);
+		System.err.println("actual: " + handle1);
+		System.err.println("actual: " + handle2);
+		if (b) {
+			assertEquals("handleIdentifier - expected " + expected2 + ", but found "
+					+ handle2, expected2, handle2);
+		} else {
+			assertEquals("handleIdentifier - expected " + expected1 + ", but found "
+					+ handle2, expected1, handle2);
+			assertEquals("handleIdentifier - expected " + expected2 + ", but found "
+					+ handle1, expected2, handle1);
+		}
+	}	
+	public void testMethodWithStringArrayArgsSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo~main~\[QString;
+		runTest("method with string array as argument same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"main(java.lang.String[])",
+				"<tjp{Demo.java[Demo~main~\\[QString;");
+	}	
+	
+	public void testMethodWithIntArrayArgsSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo~m~\[I
+		runTest("method with int array as argument same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"m(int[])",
+				"<tjp{Demo.java[Demo~m~\\[I");
+	}	
+	
+	public void testMethodWithNoArgsSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo~go
+		runTest("method with no args same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"go()",
+				"<tjp{Demo.java[Demo~go");
+	}	
+	
+	public void testMethodWithTwoArgsSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo~foo~I~QObject;
+		runTest("method with two args same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"foo(int,java.lang.Object)",
+				"<tjp{Demo.java[Demo~foo~I~QObject;");
+	}	
+	
+	public void testMethodWithTwoStringArgsSameAsJDT() {
+		// JDT: =TJP Example/src<tjp{Demo.java[Demo~m2~QString;~QString;
+		runTest("method with two string args same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"m2(java.lang.String,java.lang.String)",
+				"<tjp{Demo.java[Demo~m2~QString;~QString;");		
+	}
+	
+	public void testEnumSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{E.java[E
+		runTest("enum same as jdt");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement pe = top.findElementForType("pkg", "E");
+		String expected = "<pkg{E.java[E";
+		String found = pe.getHandleIdentifier();
+		assertEquals("handleIdentifier - expected " + expected + ", but found "
+				+ found, expected, found);	
+	}
+	
+	public void testEnumValueSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{E.java[E^A
+		runTest("enum value same as jdt");
+		compareHandles(IProgramElement.Kind.ENUM_VALUE,
+				"A","<pkg{E.java[E^A");
+	}
+	
+	public void testAnnotationSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{MyAnnotation.java[MyAnnotation
+		runTest("annotation same as jdt");
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement pe = top.findElementForType("pkg", "MyAnnotation");
+		String expected = "<pkg{MyAnnotation.java[MyAnnotation";
+		String found = pe.getHandleIdentifier();
+		assertEquals("handleIdentifier - expected " + expected + ", but found "
+				+ found, expected, found);	
+	}
+	
+	public void testMethodWithListArgSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{Java5Class.java[Java5Class~method2~QList;
+		runTest("method with list arg same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"method2(java.util.List)",
+				"<pkg{Java5Class.java[Java5Class~method2~QList;");
+	}
+	
+	public void testMethodWithGenericArgSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{Java5Class.java[Java5Class
+		//       ~genericMethod1~QList\<QString;>;
+		runTest("method with generic arg same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"genericMethod1(java.util.List<java.lang.String>)",
+				"<pkg{Java5Class.java[Java5Class~genericMethod1~QList\\<QString;>;");
+	}
+	
+	public void testMethodWithTwoGenericArgsSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{Java5Class.java[Java5Class
+		//       ~genericMethod2~QList\<QString;>;~QMyGenericClass\<QInteger;>;
+		runTest("method with two generic args same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"genericMethod2(java.util.List<java.lang.String>,"
+					+"pkg.MyGenericClass<java.lang.Integer>)",
+				"<pkg{Java5Class.java[Java5Class~genericMethod2~QList"
+					+"\\<QString;>;~QMyGenericClass\\<QInteger;>;");
+	}
+	
+	public void testMethodWithTwoTypeParametersSameAsJDT() {
+		// JDT: =Java5 Handles/src<pkg{Java5Class.java[Java5Class~genericMethod4
+		//       ~QMyGenericClass2\<QString;QInteger;>;
+		runTest("method with two type parameters same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"genericMethod4(pkg.MyGenericClass2<java.lang.String,java.lang.Integer>)",
+				"<pkg{Java5Class.java[Java5Class~genericMethod4" +
+				"~QMyGenericClass2\\<QString;QInteger;>;");
+	}
+	
+	public void testMethodWithTwoArgsSameAsJDT_2() {
+		// JDT: =Java5 Handles/src<pkg{Java5Class.java[Java5Class
+		//      ~genericMethod3~I~QList\<QString;>;
+		runTest("method with two args one of which is generic same as jdt");
+		compareHandles(IProgramElement.Kind.METHOD,
+				"genericMethod3(int,java.util.List<java.lang.String>)",
+				"<pkg{Java5Class.java[Java5Class~genericMethod3~I~QList\\<QString;>;");
+	}
+	
+	/*
+	 * Still to do;
+	 * 				PROJECT,
+				PACKAGE,
+				FILE,
+				FILE_ASPECTJ,
+				FILE_LST,
+				DECLARE_ERROR,
+				DECLARE_SOFT,
+				DECLARE_PRECEDENCE,
+	 */
+	
+	// ----------- helper methods ---------------
+	
+	private void compareHandles(IProgramElement.Kind kind, String ipeName, String expectedHandle) {
+		IHierarchy top = AsmManager.getDefault().getHierarchy();
+		IProgramElement pe = top.findElementForLabel(top.getRoot(),kind,ipeName);
+		String found = pe.getHandleIdentifier();
+		System.err.println("expected: " + expectedHandle);
+		System.err.println("actual:   " + found);
+		assertEquals("handleIdentifier - expected " + expectedHandle + ", but found "
+				+ found, expectedHandle, found);
+	}
+	
+	// ///////////////////////////////////////
+	public static Test suite() {
+		return XMLBasedAjcTestCase.loadSuite(JDTLikeHandleProviderTests.class);
+	}
+
+	protected File getSpecFile() {
+		return new File(
+				"../tests/src/org/aspectj/systemtest/ajc152/jdtlikehandleprovider.xml");
+	}
+
+}
diff --git a/tests/src/org/aspectj/systemtest/incremental/tools/MultiProjectIncrementalTests.java b/tests/src/org/aspectj/systemtest/incremental/tools/MultiProjectIncrementalTests.java
index 53f35fba9..6459e5a3a 100644
--- a/tests/src/org/aspectj/systemtest/incremental/tools/MultiProjectIncrementalTests.java
+++ b/tests/src/org/aspectj/systemtest/incremental/tools/MultiProjectIncrementalTests.java
@@ -25,13 +25,15 @@ import org.aspectj.ajdt.internal.compiler.lookup.EclipseFactory;
 import org.aspectj.ajdt.internal.core.builder.AjState;
 import org.aspectj.ajdt.internal.core.builder.IncrementalStateManager;
 import org.aspectj.asm.AsmManager;
+import org.aspectj.asm.IElementHandleProvider;
+import org.aspectj.asm.IHierarchy;
 import org.aspectj.asm.IProgramElement;
 import org.aspectj.asm.IRelationship;
 import org.aspectj.asm.IRelationshipMap;
+import org.aspectj.asm.internal.JDTLikeHandleProvider;
 import org.aspectj.asm.internal.Relationship;
 import org.aspectj.bridge.IMessage;
 import org.aspectj.tools.ajc.Ajc;
-import org.aspectj.weaver.World;
 
 /**
  * The superclass knows all about talking through Ajde to the compiler.
@@ -1040,7 +1042,7 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 				((IMessage)MyTaskListManager.getWarningMessages().get(0)).getSourceLocation().getLine());
 		alter("PR134541","inc1");
 		build("PR134541");
-		if (World.compareLocations)
+		if (AsmManager.getDefault().getHandleProvider().dependsOnLocation())
 		  checkWasFullBuild(); // the line number has changed... but nothing structural about the code
 		else 
 		  checkWasntFullBuild(); // the line number has changed... but nothing structural about the code
@@ -1048,6 +1050,131 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 				((IMessage)MyTaskListManager.getWarningMessages().get(0)).getSourceLocation().getLine());
 	}
 	
+	public void testJDTLikeHandleProviderWithLstFile_pr141730() {
+		IElementHandleProvider handleProvider = AsmManager.getDefault().getHandleProvider();
+		AsmManager.getDefault().setHandleProvider(new JDTLikeHandleProvider());
+		configureBuildStructureModel(true);
+		try {
+			// The JDTLike-handles should start with the name
+			// of the buildconfig file
+			initialiseProject("JDTLikeHandleProvider");
+			build("JDTLikeHandleProvider");
+			IHierarchy top = AsmManager.getDefault().getHierarchy();
+		  	IProgramElement pe = top.findElementForType("pkg","A");
+		  	String expectedHandle = "build<pkg*A.aj}A";
+		  	assertEquals("expected handle to be " + expectedHandle + ", but found "
+		  			+ pe.getHandleIdentifier(),expectedHandle,pe.getHandleIdentifier());	
+		} finally {
+			AsmManager.getDefault().setHandleProvider(handleProvider);
+		  	configureBuildStructureModel(false);			
+		}
+	}
+	
+	public void testMovingAdviceDoesntChangeHandles_pr141730() {
+		IElementHandleProvider handleProvider = AsmManager.getDefault().getHandleProvider();
+		AsmManager.getDefault().setHandleProvider(new JDTLikeHandleProvider());
+		configureBuildStructureModel(true);
+		try {
+			initialiseProject("JDTLikeHandleProvider");
+			build("JDTLikeHandleProvider");
+			checkWasFullBuild();
+			IHierarchy top = AsmManager.getDefault().getHierarchy();
+			IProgramElement pe = top.findElementForLabel(top.getRoot(),
+					IProgramElement.Kind.ADVICE,"before(): <anonymous pointcut>");
+		  	// add a line which shouldn't change the handle
+			alter("JDTLikeHandleProvider","inc1");
+			build("JDTLikeHandleProvider");
+			checkWasntFullBuild();
+			IHierarchy top2 = AsmManager.getDefault().getHierarchy();
+			IProgramElement pe2 = top.findElementForLabel(top2.getRoot(),
+					IProgramElement.Kind.ADVICE,"before(): <anonymous pointcut>");
+			assertEquals("expected advice to be on line " + pe.getSourceLocation().getLine() + 1 
+					+ " but was on " + pe2.getSourceLocation().getLine(),
+					pe.getSourceLocation().getLine()+1,pe2.getSourceLocation().getLine());
+			assertEquals("expected advice to have handle " + pe.getHandleIdentifier()
+					+ " but found handle " + pe2.getHandleIdentifier(),
+					pe.getHandleIdentifier(),pe2.getHandleIdentifier());		
+		} finally {
+			AsmManager.getDefault().setHandleProvider(handleProvider);
+		  	configureBuildStructureModel(false);			
+		}
+	}
+	
+	public void testSwappingAdviceAndHandles_pr141730() {
+		IElementHandleProvider handleProvider = AsmManager.getDefault().getHandleProvider();
+		AsmManager.getDefault().setHandleProvider(new JDTLikeHandleProvider());
+		configureBuildStructureModel(true);
+		try {
+			initialiseProject("JDTLikeHandleProvider");
+			build("JDTLikeHandleProvider");
+			IHierarchy top = AsmManager.getDefault().getHierarchy();
+
+			IProgramElement call = top.findElementForLabel(top.getRoot(),
+					IProgramElement.Kind.ADVICE, "after(): callPCD..");
+			IProgramElement exec = top.findElementForLabel(top.getRoot(),
+					IProgramElement.Kind.ADVICE, "after(): execPCD..");
+		  	// swap the two after advice statements over. This forces
+			// a full build which means 'after(): callPCD..' will now
+			// be the second after advice in the file and have the same
+			// handle as 'after(): execPCD..' originally did.
+			alter("JDTLikeHandleProvider","inc2");
+			build("JDTLikeHandleProvider");
+			checkWasFullBuild();
+			
+			IHierarchy top2 = AsmManager.getDefault().getHierarchy();
+			IProgramElement newCall = top2.findElementForLabel(top2.getRoot(),
+					IProgramElement.Kind.ADVICE, "after(): callPCD..");
+			IProgramElement newExec = top2.findElementForLabel(top2.getRoot(),
+					IProgramElement.Kind.ADVICE, "after(): execPCD..");
+
+			assertEquals("after swapping places, expected 'after(): callPCD..' " +
+					"to be on line " + newExec.getSourceLocation().getLine() +
+					" but was on line " + call.getSourceLocation().getLine(),
+					newExec.getSourceLocation().getLine(),
+					call.getSourceLocation().getLine());
+			assertEquals("after swapping places, expected 'after(): callPCD..' " +
+					"to have handle " + exec.getHandleIdentifier() +
+					" (because was full build) but had " + newCall.getHandleIdentifier(),
+					exec.getHandleIdentifier(), newCall.getHandleIdentifier());
+		} finally {
+			AsmManager.getDefault().setHandleProvider(handleProvider);
+		  	configureBuildStructureModel(false);			
+		}
+	}
+	
+	public void testInitializerCountForJDTLikeHandleProvider_pr141730() {
+		IElementHandleProvider handleProvider = AsmManager.getDefault().getHandleProvider();
+		AsmManager.getDefault().setHandleProvider(new JDTLikeHandleProvider());
+		configureBuildStructureModel(true);
+		try {
+			initialiseProject("JDTLikeHandleProvider");
+			build("JDTLikeHandleProvider");
+			String expected = "build<pkg*A.aj[C|1";
+
+			IHierarchy top = AsmManager.getDefault().getHierarchy();
+			IProgramElement init = top.findElementForLabel(top.getRoot(),
+					IProgramElement.Kind.INITIALIZER, "...");
+			assertEquals("expected initializers handle to be " + expected + "," +
+					" but found " + init.getHandleIdentifier(true),
+					expected,init.getHandleIdentifier(true));
+			
+			alter("JDTLikeHandleProvider","inc2");
+			build("JDTLikeHandleProvider");
+			checkWasFullBuild();
+			
+			IHierarchy top2 = AsmManager.getDefault().getHierarchy();
+			IProgramElement init2 = top2.findElementForLabel(top2.getRoot(),
+					IProgramElement.Kind.INITIALIZER, "...");
+			assertEquals("expected initializers handle to still be " + expected + "," +
+					" but found " + init2.getHandleIdentifier(true),
+					expected,init2.getHandleIdentifier(true));
+
+		
+		} finally {
+			AsmManager.getDefault().setHandleProvider(handleProvider);
+		  	configureBuildStructureModel(false);			
+		}
+	}
 	
 	// 134471 related tests perform incremental compilation and verify features of the structure model post compile
 	public void testPr134471_IncrementalCompilationAndModelUpdates() {
@@ -1105,7 +1232,12 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 		// Step3. No structural change to the aspect but the advice has moved down a few lines... (change in source location)
 		alter("PR134471_2","inc1");
 		build("PR134471_2");
-		checkWasFullBuild(); // this is true whilst we consider sourcelocation in the type/shadow munger equals() method - have to until the handles are independent of location
+		if (AsmManager.getDefault().getHandleProvider().dependsOnLocation())
+			  checkWasFullBuild(); // the line number has changed... but nothing structural about the code
+			else 
+			  checkWasntFullBuild(); // the line number has changed... but nothing structural about the code
+
+		//checkWasFullBuild(); // this is true whilst we consider sourcelocation in the type/shadow munger equals() method - have to until the handles are independent of location
 		
 		// Step4. Check we have correctly realised the advice moved to line 11
 		programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true)));
@@ -1134,38 +1266,38 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 	public void testPr134471_IncrementallyRecompilingTheAffectedClass() {
 		try {
 			// see pr148027 AsmHierarchyBuilder.shouldAddUsesPointcut=false;
-		configureBuildStructureModel(true);
-		configureNonStandardCompileOptions("-showWeaveInfo -emacssym");
-		
-		// Step1. build the project
-		initialiseProject("PR134471");
-		build("PR134471");
-		
-		// Step2. confirm advice is from correct location
-		IProgramElement programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true)));
-		int line = programElement.getSourceLocation().getLine();
-		assertTrue("advice should be at line 7 - but is at line "+line,line==7);
-
-		// Step3. No change to the aspect at all
-		alter("PR134471","inc1");
-		build("PR134471");
-		
-		// Step4. Quick check that the advice points to something...
-		IProgramElement nodeForTypeA = checkForNode("pkg","A",true);
-		IProgramElement nodeForAdvice = findAdvice(nodeForTypeA);
-		List relatedElements = getRelatedElements(nodeForAdvice,1);
+			configureBuildStructureModel(true);
+			configureNonStandardCompileOptions("-showWeaveInfo -emacssym");
+			
+			// Step1. build the project
+			initialiseProject("PR134471");
+			build("PR134471");
+			
+			// Step2. confirm advice is from correct location
+			IProgramElement programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true)));
+			int line = programElement.getSourceLocation().getLine();
+			assertTrue("advice should be at line 7 - but is at line "+line,line==7);
+	
+			// Step3. No change to the aspect at all
+			alter("PR134471","inc1");
+			build("PR134471");
+			
+			// Step4. Quick check that the advice points to something...
+			IProgramElement nodeForTypeA = checkForNode("pkg","A",true);
+			IProgramElement nodeForAdvice = findAdvice(nodeForTypeA);
+			List relatedElements = getRelatedElements(nodeForAdvice,1);
+			
+		    // Step5. No change to the file C but it should still be advised afterwards
+			alter("PR134471","inc2");
+			build("PR134471");
+			checkWasntFullBuild();
 		
-	    // Step5. No change to the file C but it should still be advised afterwards
-		alter("PR134471","inc2");
-		build("PR134471");
-		checkWasntFullBuild();
-	
-		// Step6. confirm advice is from correct location
-		programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true)));
-		line = programElement.getSourceLocation().getLine();
-		assertTrue("advice should be at line 7 - but is at line "+line,line==7);		
-	} finally {
-		// see pr148027 AsmHierarchyBuilder.shouldAddUsesPointcut=true;
+			// Step6. confirm advice is from correct location
+			programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true)));
+			line = programElement.getSourceLocation().getLine();
+			assertTrue("advice should be at line 7 - but is at line "+line,line==7);		
+		} finally {
+			// see pr148027 AsmHierarchyBuilder.shouldAddUsesPointcut=true;
 		}
 
 	}
@@ -1193,7 +1325,12 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 		// Step4. Move declare warning in the aspect
 		alter("PR134471_3","inc1");
 		build("PR134471_3");
-		checkWasFullBuild();
+		if (AsmManager.getDefault().getHandleProvider().dependsOnLocation())
+			  checkWasFullBuild(); // the line number has changed... but nothing structural about the code
+			else 
+			  checkWasntFullBuild(); // the line number has changed... but nothing structural about the code
+
+		//checkWasFullBuild();
 
 		// Step5. confirm declare warning is from correct location, decw (now at line 12) in pkg.A matches line 7 in pkg.C
 		programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true),7));
@@ -1210,6 +1347,7 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 		line = programElement.getSourceLocation().getLine();
 		assertTrue("declare warning should be at line 12 - but is at line "+line,line==12);
 
+		configureBuildStructureModel(false);
 	}
 	
 	// similar to previous test but with 'declare warning' as well as advice
@@ -1235,7 +1373,12 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 		// Step4. Move declare warning in the aspect
 		alter("PR134471_3","inc1");
 		build("PR134471_3");
-		checkWasFullBuild();
+		if (AsmManager.getDefault().getHandleProvider().dependsOnLocation())
+			  checkWasFullBuild(); // the line number has changed... but nothing structural about the code
+			else 
+			  checkWasntFullBuild(); // the line number has changed... but nothing structural about the code
+
+		//checkWasFullBuild();
 
 		// Step5. confirm declare warning is from correct location, decw (now at line 12) in pkg.A matches line 7 in pkg.C
 		programElement = getFirstRelatedElement(findCode(checkForNode("pkg","C",true),7));
@@ -1262,8 +1405,9 @@ public class MultiProjectIncrementalTests extends AbstractMultiProjectIncrementa
 		line = programElement.getSourceLocation().getLine();
 		assertTrue("declare warning should be at line 12 - but is at line "+line,line==12);
 
+		configureBuildStructureModel(false);
 	}
-
+	
 	// --- helper code ---
 	
 	/**