changed Member to be an interface with impl MemberImpl. changed ResolvedMember to be an interface with impl ResolvedMemberImpl

13 files changed, 356 insertions, 62 deletions

diff --git a/weaver/testsrc/fluffy/Base.java b/weaver/testsrc/fluffy/Base.java
index 9aa148d68..4cdb1f772 100644
--- a/weaver/testsrc/fluffy/Base.java
+++ b/weaver/testsrc/fluffy/Base.java
@@ -4,6 +4,9 @@ public class Base {
 
 	public static void onlyBase() {}
 	public static void both() {}
+	
+	public void onlyBaseNonStatic() {}
+	public void bothNonStatic() {}
 
 	public int onlyBase;
 	public int both;
diff --git a/weaver/testsrc/fluffy/Derived.java b/weaver/testsrc/fluffy/Derived.java
index 6c38db40e..ad0842c18 100644
--- a/weaver/testsrc/fluffy/Derived.java
+++ b/weaver/testsrc/fluffy/Derived.java
@@ -7,6 +7,9 @@ public class Derived extends Base {
 	public static void onlyDerived() throws IOException, CloneNotSupportedException {}
 	public static void both() {}
 	
+	public void onlyDerivedNonStatic() {}
+	public void bothNonStatic() {}
+	
 	public int onlyDerived;
 	public int both;
 	
diff --git a/weaver/testsrc/org/aspectj/weaver/MemberTestCase.java b/weaver/testsrc/org/aspectj/weaver/MemberTestCase.java
index d0b8e7812..cc242c2e4 100644
--- a/weaver/testsrc/org/aspectj/weaver/MemberTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/MemberTestCase.java
@@ -30,10 +30,10 @@ public class MemberTestCase extends TestCase {
     }
 
     public void testMethodConstruction() {
-        Member s = Member.methodFromString("void Foo.goo(int)");
-        Member t = Member.method(UnresolvedType.forName("Foo"), 0, "goo", "(I)V");
-        Member u = Member.methodFromString("void Foo1.goo(int)");
-        Member v = Member.methodFromString("int Foo.goo(int)");
+        Member s = MemberImpl.methodFromString("void Foo.goo(int)");
+        Member t = MemberImpl.method(UnresolvedType.forName("Foo"), 0, "goo", "(I)V");
+        Member u = MemberImpl.methodFromString("void Foo1.goo(int)");
+        Member v = MemberImpl.methodFromString("int Foo.goo(int)");
 
         TestUtil.assertCommutativeEquals(s, s, true);
         TestUtil.assertCommutativeEquals(t, t, true);
@@ -46,10 +46,10 @@ public class MemberTestCase extends TestCase {
         TestUtil.assertCommutativeEquals(t, v, false);
         TestUtil.assertCommutativeEquals(u, v, false);
 
-        s = Member.fieldFromString("int Foo.goo");
-        t = Member.field("Foo", 0, "goo", "I");
-        u = Member.fieldFromString("int Foo.goo1");
-        v = Member.fieldFromString("long Foo.goo");
+        s = MemberImpl.fieldFromString("int Foo.goo");
+        t = MemberImpl.field("Foo", 0, "goo", "I");
+        u = MemberImpl.fieldFromString("int Foo.goo1");
+        v = MemberImpl.fieldFromString("long Foo.goo");
 
         TestUtil.assertCommutativeEquals(s, s, true);
         TestUtil.assertCommutativeEquals(t, t, true);
@@ -65,7 +65,7 @@ public class MemberTestCase extends TestCase {
 
 
     public void testMethodContents() {
-        Member m = Member.methodFromString("void Foo.goo(int)");
+        Member m = MemberImpl.methodFromString("void Foo.goo(int)");
         kindTest(m, Member.METHOD);
         declaringTypeTest(m, "Foo");
         nameTest(m, "goo");
@@ -76,7 +76,7 @@ public class MemberTestCase extends TestCase {
         isConstructorTest(m, false);
         isStaticTest(m, false);
 
-        m = Member.methodFromString("interface java.lang.Object java.util.Iterator.next()");
+        m = MemberImpl.methodFromString("interface java.lang.Object java.util.Iterator.next()");
         kindTest(m, Member.METHOD);
         declaringTypeTest(m, "java.util.Iterator");
         nameTest(m, "next");
@@ -87,7 +87,7 @@ public class MemberTestCase extends TestCase {
         isConstructorTest(m, false);
         isStaticTest(m, false);
 
-        m = Member.methodFromString("void Foo.<init>(int, java.lang.Object)");
+        m = MemberImpl.methodFromString("void Foo.<init>(int, java.lang.Object)");
         kindTest(m, Member.CONSTRUCTOR);
         declaringTypeTest(m, "Foo");
         nameTest(m, "<init>");
@@ -98,7 +98,7 @@ public class MemberTestCase extends TestCase {
         isConstructorTest(m, true);
         isStaticTest(m, false);
 
-        m = Member.methodFromString("private double Foo.sqrt(double)");
+        m = MemberImpl.methodFromString("private double Foo.sqrt(double)");
         kindTest(m, Member.METHOD);
         declaringTypeTest(m, "Foo");
         nameTest(m, "sqrt");
@@ -109,7 +109,7 @@ public class MemberTestCase extends TestCase {
         isConstructorTest(m, false);
         isStaticTest(m, false);
 
-        m = Member.methodFromString("static int java.lang.Math.max(int, int)");
+        m = MemberImpl.methodFromString("static int java.lang.Math.max(int, int)");
         kindTest(m, Member.METHOD);
         declaringTypeTest(m, "java.lang.Math");
         nameTest(m, "max");
@@ -122,7 +122,7 @@ public class MemberTestCase extends TestCase {
     }
 
     public void testFieldContents() {
-        Member m = Member.fieldFromString("int Foo.goo");
+        Member m = MemberImpl.fieldFromString("int Foo.goo");
         kindTest(m, Member.FIELD);
         declaringTypeTest(m, "Foo");
         nameTest(m, "goo");
@@ -133,7 +133,7 @@ public class MemberTestCase extends TestCase {
         isConstructorTest(m, false);
         isStaticTest(m, false);
 
-        m = Member.fieldFromString("static java.util.Iterator goo.Bar.i");
+        m = MemberImpl.fieldFromString("static java.util.Iterator goo.Bar.i");
         kindTest(m, Member.FIELD);
         declaringTypeTest(m, "goo.Bar");
         nameTest(m, "i");
@@ -169,7 +169,7 @@ public class MemberTestCase extends TestCase {
     private void declaringTypeTest(Member m, String declaringName) {
         assertEquals(m + " declared in", UnresolvedType.forName(declaringName), m.getDeclaringType());
     }
-    private void kindTest(Member m, Member.Kind kind) {
+    private void kindTest(Member m, MemberImpl.Kind kind) {
         assertEquals(m + " kind", kind, m.getKind());
     }   
    
diff --git a/weaver/testsrc/org/aspectj/weaver/ResolvedMemberSignaturesTestCase15.java b/weaver/testsrc/org/aspectj/weaver/ResolvedMemberSignaturesTestCase15.java
new file mode 100644
index 000000000..95ce63e3f
--- /dev/null
+++ b/weaver/testsrc/org/aspectj/weaver/ResolvedMemberSignaturesTestCase15.java
@@ -0,0 +1,286 @@
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *   Adrian Colyer			Initial implementation
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import java.lang.reflect.Modifier;
+
+import org.aspectj.weaver.bcel.BcelWorld;
+
+import junit.framework.TestCase;
+
+public class ResolvedMemberSignaturesTestCase15 extends TestCase {
+
+	World world;
+	UnresolvedType baseType;
+	UnresolvedType derivedType;
+	
+	// STATIC METHODS
+	
+	public void testBaseOnlyStaticMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+								   (Modifier.PUBLIC | Modifier.STATIC),
+								   UnresolvedType.forSignature("V"),
+								   "onlyBase",
+								   new UnresolvedType[0]
+								   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+				   (Modifier.PUBLIC | Modifier.STATIC),
+				   UnresolvedType.forSignature("V"),
+				   "onlyBase",
+				   new UnresolvedType[0]
+				   );
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		// this looks odd but we need both because of the way calls to inherited static methods
+		// are rendered in bytecode when written as obj.foo(); - the bytecode says it is a call
+		// to obj.getClass().foo() even if the static method is defined in a super type.
+		assertEquals("found 2 members",2,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());		
+		assertEquals("Lfluffy/Base;",foundMembers[1].getDeclaringType().getSignature());
+	}
+	
+	public void testBothStaticMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+				   (Modifier.PUBLIC | Modifier.STATIC),
+				   UnresolvedType.forSignature("V"),
+				   "both",
+				   new UnresolvedType[0]
+				   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+							(Modifier.PUBLIC | Modifier.STATIC),
+							UnresolvedType.forSignature("V"),
+							"both",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());		
+	}
+
+	public void testDerivedStaticMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+				   (Modifier.PUBLIC | Modifier.STATIC),
+				   UnresolvedType.forSignature("V"),
+				   "onlyDerived",
+				   new UnresolvedType[0]
+				   );
+		
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found nothing",0,foundMembers.length);
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+							(Modifier.PUBLIC | Modifier.STATIC),
+							UnresolvedType.forSignature("V"),
+							"onlyDerived",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());		
+	}
+	
+	// NON-STATIC METHODS
+	
+	public void testBaseOnlyMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+								   Modifier.PUBLIC,
+								   UnresolvedType.forSignature("V"),
+								   "onlyBaseNonStatic",
+								   new UnresolvedType[0]
+								   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "onlyBaseNonStatic",
+				   new UnresolvedType[0]
+				   );
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 2 members",2,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());
+		assertEquals("Lfluffy/Base;",foundMembers[1].getDeclaringType().getSignature());
+
+	}
+	
+	public void testBothMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "bothNonStatic",
+				   new UnresolvedType[0]
+				   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+							Modifier.PUBLIC,
+							UnresolvedType.forSignature("V"),
+							"bothNonStatic",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 2 members",2,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());
+		assertEquals("Lfluffy/Base;",foundMembers[1].getDeclaringType().getSignature());
+	}
+
+	public void testDerivedMethod() {
+		Member toFind = new MemberImpl(Member.METHOD,baseType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "onlyDerivedNonStatic",
+				   new UnresolvedType[0]
+				   );
+		
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found nothing",0,foundMembers.length);
+		
+		toFind = new MemberImpl(Member.METHOD,derivedType,
+							Modifier.PUBLIC,
+							UnresolvedType.forSignature("V"),
+							"onlyDerivedNonStatic",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());		
+	}
+	
+	public void testChangingThrowsClause() {
+		Member toFind = new MemberImpl(Member.METHOD,derivedType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "m",
+				   new UnresolvedType[0]
+				   );
+		
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 2 members",2,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());
+		assertEquals("Lfluffy/Base;",foundMembers[1].getDeclaringType().getSignature());
+		
+		assertEquals("throws CloneNotSupported",1,foundMembers[1].getExceptions().length);
+		assertEquals("doesn't throw anything",0,foundMembers[0].getExceptions().length);
+	}
+	
+	// CONSTRUCTORS
+	
+	 public void testNoWalkUpMatchingConstructor() {
+		Member toFind = new MemberImpl(Member.CONSTRUCTOR,derivedType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "<init>",
+				   new UnresolvedType[0]
+				   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());			
+	 }
+	 
+	 public void testNoWalkUpNoMatchingConstructor() {
+		Member toFind = new MemberImpl(Member.CONSTRUCTOR,derivedType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("V"),
+				   "<init>",
+				   new UnresolvedType[] {UnresolvedType.forSignature("I")}
+				   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("No matches",0,foundMembers.length);
+	 }
+	
+	// FIELDS
+	 
+	public void testBaseOnlyField() {
+		Member toFind = new MemberImpl(Member.FIELD,baseType,
+								   Modifier.PUBLIC,
+								   UnresolvedType.forSignature("I"),
+								   "onlyBase",
+								   new UnresolvedType[0]
+								   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.FIELD,derivedType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("I"),
+				   "onlyBase",
+				   new UnresolvedType[0]
+				   );
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 2 members",2,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());
+		assertEquals("Lfluffy/Base;",foundMembers[1].getDeclaringType().getSignature());
+	}
+	
+	public void testBothField() {
+		Member toFind = new MemberImpl(Member.FIELD,baseType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("I"),
+				   "both",
+				   new UnresolvedType[0]
+				   );
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 member",1,foundMembers.length);
+		assertEquals("Lfluffy/Base;",foundMembers[0].getDeclaringType().getSignature());
+		
+		toFind = new MemberImpl(Member.FIELD,derivedType,
+							Modifier.PUBLIC,
+							UnresolvedType.forSignature("I"),
+							"both",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());
+	}
+
+	public void testDerivedField() {
+		Member toFind = new MemberImpl(Member.FIELD,baseType,
+				   Modifier.PUBLIC,
+				   UnresolvedType.forSignature("I"),
+				   "onlyDerived",
+				   new UnresolvedType[0]
+				   );
+		
+		ResolvedMember[] foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found nothing",0,foundMembers.length);
+		
+		toFind = new MemberImpl(Member.FIELD,derivedType,
+							Modifier.PUBLIC,
+							UnresolvedType.forSignature("I"),
+							"onlyDerived",
+							new UnresolvedType[0]
+							);
+		foundMembers = ResolvedMemberImpl.getJoinPointSignatures(toFind, world);
+		assertEquals("found 1 members",1,foundMembers.length);
+		assertEquals("Lfluffy/Derived;",foundMembers[0].getDeclaringType().getSignature());		
+	}	 
+
+	protected void setUp() throws Exception {
+		world = new BcelWorld();
+		baseType = UnresolvedType.forSignature("Lfluffy/Base;");
+		derivedType = UnresolvedType.forSignature("Lfluffy/Derived;");
+	}
+	
+}
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/ArgsWeaveTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/ArgsWeaveTestCase.java
index c487d24d7..722e4a83c 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/ArgsWeaveTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/ArgsWeaveTestCase.java
@@ -23,7 +23,7 @@ import org.aspectj.apache.bcel.generic.InstructionHandle;
 import org.aspectj.apache.bcel.generic.InstructionList;
 import org.aspectj.apache.bcel.generic.Type;
 import org.aspectj.weaver.AdviceKind;
-import org.aspectj.weaver.Member;
+import org.aspectj.weaver.MemberImpl;
 import org.aspectj.weaver.ResolvedType;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.UnresolvedType;
@@ -103,7 +103,7 @@ public class ArgsWeaveTestCase extends WeaveTestCase {
     	ResolvedType rtx = world.resolve(UnresolvedType.forName("Aspect"),true);
     	assertTrue("Cant find required type Aspect",rtx!=ResolvedType.MISSING);
         return new BcelAdvice(AdviceKind.stringToKind(kindx), makePointcutNoZeroArg(),
-        			Member.method(UnresolvedType.forName("Aspect"), 0, "foo", "()V"), 0, -1, -1, null,
+        			MemberImpl.method(UnresolvedType.forName("Aspect"), 0, "foo", "()V"), 0, -1, -1, null,
         			rtx) {
             public void specializeOn(Shadow shadow) {
                 super.specializeOn(shadow);
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/AroundWeaveTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/AroundWeaveTestCase.java
index 023005e53..2e892277d 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/AroundWeaveTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/AroundWeaveTestCase.java
@@ -48,7 +48,7 @@ public class AroundWeaveTestCase extends WeaveTestCase {
     private BcelAdvice makeAroundMunger(final boolean matchOnlyPrintln) {
         BcelWorld world = super.world;
         final Member sig =
-            Member.method(
+            MemberImpl.method(
                 UnresolvedType.forName("Aspect"),
                 Modifier.STATIC,
                 "ajc_around",
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/MegaZipTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/MegaZipTestCase.java
index ac57a0ba7..fed1ab4cd 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/MegaZipTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/MegaZipTestCase.java
@@ -22,6 +22,7 @@ import java.util.List;
 import org.aspectj.weaver.AdviceKind;
 import org.aspectj.weaver.BcweaverTests;
 import org.aspectj.weaver.Member;
+import org.aspectj.weaver.MemberImpl;
 import org.aspectj.weaver.Shadow;
 import org.aspectj.weaver.UnresolvedType;
 
@@ -46,7 +47,7 @@ public class MegaZipTestCase extends WeaveTestCase {
     private BcelAdvice makeAroundMunger(final boolean matchOnlyPrintln) {
         // BcelWorld world = new BcelWorld();
         final Member sig = 
-            Member.method(
+            MemberImpl.method(
                 UnresolvedType.forName("fluffy.Aspect"),
                 Modifier.STATIC,
                 "aroundFun",
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/PointcutResidueTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/PointcutResidueTestCase.java
index 428ab5ed2..3c2701241 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/PointcutResidueTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/PointcutResidueTestCase.java
@@ -186,11 +186,11 @@ public class PointcutResidueTestCase extends WeaveTestCase {
             new BcelAdvice(
                 AdviceKind.Before,
                 rp,
-                Member.method(
+                MemberImpl.method(
                     UnresolvedType.forName("Aspect"),
                     Modifier.STATIC,
                     "ajc_before_0",
-                    Member.typesToSignature(
+                    MemberImpl.typesToSignature(
                         ResolvedType.VOID,
                         UnresolvedType.forNames(formalTypes),false)),
             	0, -1, -1, null, null);
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/TjpWeaveTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/TjpWeaveTestCase.java
index 4fe362973..a028f9a98 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/TjpWeaveTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/TjpWeaveTestCase.java
@@ -18,7 +18,7 @@ import java.util.Arrays;
 
 import org.aspectj.weaver.Advice;
 import org.aspectj.weaver.AdviceKind;
-import org.aspectj.weaver.Member;
+import org.aspectj.weaver.MemberImpl;
 import org.aspectj.weaver.ResolvedType;
 import org.aspectj.weaver.UnresolvedType;
 
@@ -36,7 +36,7 @@ public class TjpWeaveTestCase extends WeaveTestCase {
     	BcelAdvice munger = new BcelAdvice(
     		AdviceKind.stringToKind("before"),
     		makePointcutAll(), 
-      		Member.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint$StaticPart)"),
+      		MemberImpl.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint$StaticPart)"),
     		Advice.ThisJoinPointStaticPart, -1, -1, null, null);
     	
         weaveTest("HelloWorld", "StaticTjpBeforeHelloWorld", munger);
@@ -47,7 +47,7 @@ public class TjpWeaveTestCase extends WeaveTestCase {
     	BcelAdvice munger = new BcelAdvice(
     		AdviceKind.stringToKind("before"),
     		makePointcutAll(), 
-      		Member.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint$StaticPart)"),
+      		MemberImpl.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint$StaticPart)"),
     		Advice.ThisEnclosingJoinPointStaticPart, -1, -1, null, null);
     	
         weaveTest("HelloWorld", "StaticEnclosingTjpBeforeHelloWorld", munger);
@@ -58,7 +58,7 @@ public class TjpWeaveTestCase extends WeaveTestCase {
     	BcelAdvice munger = new BcelAdvice(
     		AdviceKind.stringToKind("before"),
     		makePointcutAll(), 
-      		Member.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint)"),
+      		MemberImpl.methodFromString("static void Aspect.ajc_before(org.aspectj.lang.JoinPoint)"),
     		Advice.ThisJoinPoint, -1, -1, null, null);
     	
         weaveTest("HelloWorld", "TjpBeforeHelloWorld", munger);
@@ -68,7 +68,7 @@ public class TjpWeaveTestCase extends WeaveTestCase {
     	BcelAdvice munger = new BcelAdvice(
     		AdviceKind.stringToKind("around"),
     		makePointcutAll(), 
-      		Member.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
+      		MemberImpl.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
     		Advice.ThisJoinPoint | Advice.ExtraArgument, -1, -1, null, null);
     	
         weaveTest("HelloWorld", "TjpAroundHelloWorld", munger);
@@ -80,14 +80,14 @@ public class TjpWeaveTestCase extends WeaveTestCase {
     	BcelAdvice munger1 = new BcelAdvice(
     		AdviceKind.stringToKind("around"),
     		makePointcutAll(), 
-      		Member.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
+      		MemberImpl.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
     		Advice.ThisJoinPoint | Advice.ExtraArgument, -1, -1, null, 
     		rtx);
     	
     	BcelAdvice munger2 = new BcelAdvice(
     		AdviceKind.stringToKind("around"),
     		makePointcutAll(), 
-      		Member.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
+      		MemberImpl.methodFromString("static java.lang.Object Aspect.ajc_around(org.aspectj.runtime.internal.AroundClosure, org.aspectj.lang.JoinPoint)"),
     		Advice.ThisJoinPoint | Advice.ExtraArgument, -1, -1, null, 
     		rtx);
     	
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/WeaveOrderTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/WeaveOrderTestCase.java
index 5696a1df5..5976acd03 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/WeaveOrderTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/WeaveOrderTestCase.java
@@ -138,7 +138,7 @@ public class WeaveOrderTestCase extends WeaveTestCase {
 				UnresolvedType concreteAspect, int lexicalPosition)
 	{
 		Advice a1 = new BcelAdvice(kind, makeResolvedPointcut("this(*)"),  
-				Member.method(declaringAspect, 0, "foo", "()V"),
+				MemberImpl.method(declaringAspect, 0, "foo", "()V"),
 				0, lexicalPosition, lexicalPosition, null, null);
 		a1 = (Advice)a1.concretize(concreteAspect.resolve(world), world, null);
 		return a1;
diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/WorldTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/WorldTestCase.java
index e3cd0e3fa..cb82a2f5f 100644
--- a/weaver/testsrc/org/aspectj/weaver/bcel/WorldTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/bcel/WorldTestCase.java
@@ -38,7 +38,7 @@ public class WorldTestCase extends AbstractWorldTestCase {
         ResolvedType trace = world.resolve(UnresolvedType.forName("Trace"),true);
         assertTrue("Couldnt find type Trace",trace!=ResolvedType.MISSING);
         fieldsTest(trace, Member.NONE);
-        /*Member constr = */Member.methodFromString("void Trace.<init>()"); 
+        /*Member constr = */MemberImpl.methodFromString("void Trace.<init>()"); 
         //XXX need attribute fix - 
         //methodsTest(trace, new Member[] { constr });
 
@@ -50,7 +50,7 @@ public class WorldTestCase extends AbstractWorldTestCase {
 
         pointcutsTest(trace, 
             new Member[] {
-                Member.pointcut(trace, "traced", "(Ljava/lang/Object;)V"),
+                MemberImpl.pointcut(trace, "traced", "(Ljava/lang/Object;)V"),
             });
 
         modifiersTest(trace.findPointcut("traced"), 
@@ -83,7 +83,7 @@ public class WorldTestCase extends AbstractWorldTestCase {
 
         pointcutsTest(trace, 
             new Member[] {
-                Member.pointcut(trace, "traced", "(Ljava/lang/Object;)V"),
+                MemberImpl.pointcut(trace, "traced", "(Ljava/lang/Object;)V"),
             });
 
         modifiersTest(myTrace.findPointcut("traced"), 
@@ -102,16 +102,16 @@ public class WorldTestCase extends AbstractWorldTestCase {
         fieldsTest(iter, ResolvedMember.NONE);
         methodsTest(iter, 
             new Member[] {
-                Member.method(iter, 0, "hasNext", "()Z"),
-                Member.method(iter, 0, "remove", "()V"),
-                Member.method(iter, 0, "next", "()Ljava/lang/Object;"),
+                MemberImpl.method(iter, 0, "hasNext", "()Z"),
+                MemberImpl.method(iter, 0, "remove", "()V"),
+                MemberImpl.method(iter, 0, "next", "()Ljava/lang/Object;"),
                 });
-        ResolvedMember remove = iter.lookupMethod(Member.method(iter, 0, "remove", "()V"));
+        ResolvedMember remove = iter.lookupMethod(MemberImpl.method(iter, 0, "remove", "()V"));
         assertNotNull("iterator doesn't have remove" , remove);
         modifiersTest(remove, abstractPublic | Modifier.INTERFACE);
         exceptionsTest(remove, UnresolvedType.NONE);
 
-        ResolvedMember clone = iter.lookupMethod(Member.method(UnresolvedType.OBJECT, 0, "clone", "()Ljava/lang/Object;"));
+        ResolvedMember clone = iter.lookupMethod(MemberImpl.method(UnresolvedType.OBJECT, 0, "clone", "()Ljava/lang/Object;"));
         assertNotNull("iterator doesn't have clone" , clone);
         //AV: JRockit Object.clone() is not native.. corrupted test here:
         //modifiersTest(clone, Modifier.PROTECTED | Modifier.NATIVE);
diff --git a/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java b/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java
index 4a9188bbc..d784afc70 100644
--- a/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/patterns/SignaturePatternTestCase.java
@@ -1,5 +1,6 @@
 /* *******************************************************************
  * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ *               2005 Contributors
  * All rights reserved. 
  * This program and the accompanying materials are made available 
  * under the terms of the Common Public License v1.0 
@@ -32,13 +33,13 @@ public class SignaturePatternTestCase extends TestCase {
 	BcelWorld world = new BcelWorld();
 
 	public void testThrowsMatch() throws IOException {
-		Member onlyDerivedOnDerived = Member.methodFromString("static void fluffy.Derived.onlyDerived()");
-		Member mOnBase = Member.methodFromString("void fluffy.Base.m()");
-		Member mOnDerived = Member.methodFromString("void fluffy.Derived.m()");
+		Member onlyDerivedOnDerived = MemberImpl.methodFromString("static void fluffy.Derived.onlyDerived()");
+		Member mOnBase = MemberImpl.methodFromString("void fluffy.Base.m()");
+		Member mOnDerived = MemberImpl.methodFromString("void fluffy.Derived.m()");
 		
 		checkMatch(makeMethodPat("* fluffy.Base.*(..) throws java.lang.CloneNotSupportedException"),
-					new Member[] { mOnBase },
-					new Member[] { mOnDerived });
+					new Member[] { mOnBase, mOnDerived },
+					new Member[] { });
 					
 		checkMatch(makeMethodPat("* fluffy.Derived.*(..) throws java.lang.CloneNotSupportedException"),
 					new Member[] { },
@@ -52,7 +53,7 @@ public class SignaturePatternTestCase extends TestCase {
 		
 		checkMatch(makeMethodPat("* *(..)"), M, NONE);
 		checkMatch(makeMethodPat("* *(..) throws !*"), NO_EXCEPTIONS, M);
-		checkMatch(makeMethodPat("* *(..) throws *"), M, NO_EXCEPTIONS);
+		checkMatch(makeMethodPat("* *(..) throws *"), BOTH, NONE);
 		checkMatch(makeMethodPat("* *(..) throws *, !*"), NONE, BOTH);
 		
 		checkMatch(makeMethodPat("* *(..) throws (!*)"), NONE, BOTH);		
@@ -65,9 +66,9 @@ public class SignaturePatternTestCase extends TestCase {
 	}
 
 	public void testInstanceMethodMatch() throws IOException {
-		Member objectToString = Member.methodFromString("java.lang.String java.lang.Object.toString()");
-		Member integerToString = Member.methodFromString("java.lang.String java.lang.Integer.toString()");
-		Member integerIntValue = Member.methodFromString("int java.lang.Integer.intValue()");
+		Member objectToString = MemberImpl.methodFromString("java.lang.String java.lang.Object.toString()");
+		Member integerToString = MemberImpl.methodFromString("java.lang.String java.lang.Integer.toString()");
+		Member integerIntValue = MemberImpl.methodFromString("int java.lang.Integer.intValue()");
 		//Member objectToString = Member.methodFromString("java.lang.String java.lang.Object.toString()");
 		
 		checkMatch(makeMethodPat("* java.lang.Object.*(..)"),
@@ -81,11 +82,11 @@ public class SignaturePatternTestCase extends TestCase {
 
 	
 	public void testStaticMethodMatch() throws IOException {
-		Member onlyBaseOnBase = Member.methodFromString("static void fluffy.Base.onlyBase()");
-		Member onlyBaseOnDerived = Member.methodFromString("static void fluffy.Derived.onlyBase()");
-		Member onlyDerivedOnDerived = Member.methodFromString("static void fluffy.Derived.onlyDerived()");
-		Member bothOnBase = Member.methodFromString("static void fluffy.Base.both()");
-		Member bothOnDerived = Member.methodFromString("static void fluffy.Derived.both()");
+		Member onlyBaseOnBase = MemberImpl.methodFromString("static void fluffy.Base.onlyBase()");
+		Member onlyBaseOnDerived = MemberImpl.methodFromString("static void fluffy.Derived.onlyBase()");
+		Member onlyDerivedOnDerived = MemberImpl.methodFromString("static void fluffy.Derived.onlyDerived()");
+		Member bothOnBase = MemberImpl.methodFromString("static void fluffy.Base.both()");
+		Member bothOnDerived = MemberImpl.methodFromString("static void fluffy.Derived.both()");
 		
 		checkMatch(makeMethodPat("* fluffy.Base.*(..)"),
 					new Member[] { onlyBaseOnBase, onlyBaseOnDerived, bothOnBase },
@@ -97,11 +98,11 @@ public class SignaturePatternTestCase extends TestCase {
 	}
 	
 	public void testFieldMatch() throws IOException {
-		Member onlyBaseOnBase = Member.fieldFromString("int fluffy.Base.onlyBase");
-		Member onlyBaseOnDerived = Member.fieldFromString("int fluffy.Derived.onlyBase");
-		Member onlyDerivedOnDerived = Member.fieldFromString("int fluffy.Derived.onlyDerived");
-		Member bothOnBase = Member.fieldFromString("int fluffy.Base.both");
-		Member bothOnDerived = Member.fieldFromString("int fluffy.Derived.both");
+		Member onlyBaseOnBase = MemberImpl.fieldFromString("int fluffy.Base.onlyBase");
+		Member onlyBaseOnDerived = MemberImpl.fieldFromString("int fluffy.Derived.onlyBase");
+		Member onlyDerivedOnDerived = MemberImpl.fieldFromString("int fluffy.Derived.onlyDerived");
+		Member bothOnBase = MemberImpl.fieldFromString("int fluffy.Base.both");
+		Member bothOnDerived = MemberImpl.fieldFromString("int fluffy.Derived.both");
 		
 		checkMatch(makeFieldPat("* fluffy.Base.*"),
 					new Member[] { onlyBaseOnBase, onlyBaseOnDerived, bothOnBase },
@@ -113,9 +114,9 @@ public class SignaturePatternTestCase extends TestCase {
 	}
 	
 	public void testConstructorMatch() throws IOException {
-		Member onBase = Member.methodFromString("void fluffy.Base.<init>()");
-		Member onDerived = Member.methodFromString("void fluffy.Derived.<init>()");
-		Member onBaseWithInt = Member.methodFromString("void fluffy.Base.<init>(int)");
+		Member onBase = MemberImpl.methodFromString("void fluffy.Base.<init>()");
+		Member onDerived = MemberImpl.methodFromString("void fluffy.Derived.<init>()");
+		Member onBaseWithInt = MemberImpl.methodFromString("void fluffy.Base.<init>(int)");
 
 		
 		checkMatch(makeMethodPat("fluffy.Base.new(..)"),
diff --git a/weaver/testsrc/org/aspectj/weaver/patterns/WithinTestCase.java b/weaver/testsrc/org/aspectj/weaver/patterns/WithinTestCase.java
index bfbe18bc0..b0a0fb259 100644
--- a/weaver/testsrc/org/aspectj/weaver/patterns/WithinTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/patterns/WithinTestCase.java
@@ -34,7 +34,7 @@ public class WithinTestCase extends TestCase {
 	public void testMatch() throws IOException {
 		Shadow getOutFromArrayList = new TestShadow(
 			Shadow.FieldGet, 
-			Member.fieldFromString("java.io.PrintStream java.lang.System.out"),
+			MemberImpl.fieldFromString("java.io.PrintStream java.lang.System.out"),
 			UnresolvedType.forName("java.util.ArrayList"),
 			world);
 
@@ -50,7 +50,7 @@ public class WithinTestCase extends TestCase {
 		
 		Shadow getOutFromEntry = new TestShadow(
 			Shadow.FieldGet, 
-			Member.fieldFromString("java.io.PrintStream java.lang.System.out"),
+			MemberImpl.fieldFromString("java.io.PrintStream java.lang.System.out"),
 			UnresolvedType.forName("java.util.Map$Entry"),
 			world);