From d1e5c0a57c5da220b8f7357550db84f1009dbe2e Mon Sep 17 00:00:00 2001
From: jhugunin <jhugunin>
Date: Thu, 6 Mar 2003 00:24:39 +0000
Subject: [PATCH] FIXED: Bugzilla Bug 32463    ajc reports error when
 encountering static declaration of nested classes

---
 tests/ajcTests.xml                            | 14 +++++++
 tests/bugs/WeaveLocal.java                    | 37 +++++++++++++++++++
 tests/jimTests.xml                            |  7 +---
 .../src/org/aspectj/weaver/NameMangler.java   |  9 +----
 .../src/org/aspectj/weaver/ResolvedTypeX.java | 30 ++++++++++++---
 weaver/src/org/aspectj/weaver/TypeX.java      | 29 +++++++--------
 .../weaver/patterns/WithinPointcut.java       |  5 ++-
 .../org/aspectj/weaver/TypeXTestCase.java     |  4 +-
 8 files changed, 95 insertions(+), 40 deletions(-)
 create mode 100644 tests/bugs/WeaveLocal.java

diff --git a/tests/ajcTests.xml b/tests/ajcTests.xml
index df307d751..a43286131 100644
--- a/tests/ajcTests.xml
+++ b/tests/ajcTests.xml
@@ -5585,5 +5585,19 @@
             <message kind="error" line="22"/>
         </compile>
     </ajc-test>
+    
+    <ajc-test dir="bugs" pr="33635" 
+    		title="Negation of if pointcut does not work">
+        <compile files="NotIf.java"/>
+        <run class="NotIf"/>
+    </ajc-test>
+    
+    
+    <ajc-test dir="bugs" pr="32463" 
+    		title="ajc reports error when encountering static declaration of nested classes">
+        <compile files="WeaveLocal.java"/>
+        <run class="WeaveLocal"/>
+    </ajc-test>
+    
 
 </suite>
diff --git a/tests/bugs/WeaveLocal.java b/tests/bugs/WeaveLocal.java
new file mode 100644
index 000000000..25c882afd
--- /dev/null
+++ b/tests/bugs/WeaveLocal.java
@@ -0,0 +1,37 @@
+// for Bug#:  32463  
+import org.aspectj.testing.Tester;
+
+
+public class WeaveLocal
+{
+    // Commenting out the static declaration makes everything work OK
+    static
+    {
+        class StaticNestedClass
+        {
+        }
+    }
+    
+    public static void main(String[] args)
+    {
+      System.out.println(new WeaveLocal().handleOrder("test"));
+    }
+
+    private String handleOrder(String t)
+    {
+      return t;
+    }
+
+}
+
+aspect A  {
+
+    pointcut withinTest(): within(WeaveLocal);
+    pointcut callToHandleOrder() : (withinTest() &&
+                             call(* handleOrder(..)));
+
+    Object around(): callToHandleOrder() {
+
+      return "DUMMY inserted by ASPECT" ;
+   }
+}
diff --git a/tests/jimTests.xml b/tests/jimTests.xml
index 6306ec843..b8771ef2a 100644
--- a/tests/jimTests.xml
+++ b/tests/jimTests.xml
@@ -1,12 +1,7 @@
 <!DOCTYPE suite SYSTEM "../tests/ajcTestSuite.dtd">
 <suite>
 
-    <ajc-test dir="bugs" pr="33635" 
-    		title="Negation of if pointcut does not work">
-        <compile files="NotIf.java"/>
-        <run class="NotIf"/>
-    </ajc-test>
-    
+
     
     <!--
     
diff --git a/weaver/src/org/aspectj/weaver/NameMangler.java b/weaver/src/org/aspectj/weaver/NameMangler.java
index d554fc43d..823eaf215 100644
--- a/weaver/src/org/aspectj/weaver/NameMangler.java
+++ b/weaver/src/org/aspectj/weaver/NameMangler.java
@@ -268,16 +268,9 @@ public class NameMangler {
 
 	// ----
 
-	private static TypeX getOutermostType(TypeX type) {
-		TypeX outerType = type.getDeclaringType();
-		if (outerType == null) return type;
-		return getOutermostType(outerType);
-	}
-
-
 	private static String makeVisibilityName(int modifiers, TypeX aspectType) {
 		if (Modifier.isPrivate(modifiers)) {
-			return getOutermostType(aspectType).getNameAsIdentifier();
+			return aspectType.getOutermostType().getNameAsIdentifier();
 		} else if (Modifier.isProtected(modifiers)) {
 			throw new RuntimeException("protected inter-types not allowed");
 		} else if (Modifier.isPublic(modifiers)) {
diff --git a/weaver/src/org/aspectj/weaver/ResolvedTypeX.java b/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
index cfce3b03c..2123acf8e 100644
--- a/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
+++ b/weaver/src/org/aspectj/weaver/ResolvedTypeX.java
@@ -792,11 +792,29 @@ public abstract class ResolvedTypeX extends TypeX {
 		return interTypeMungers;
 	}
 	
-	private static ResolvedTypeX getOutermostType(ResolvedTypeX t) {
-		TypeX dec = t.getDeclaringType();
-		if (dec == null) return t;
-		return getOutermostType(dec.resolve(t.getWorld()));
-	}
+    /**
+     * Returns a ResolvedTypeX object representing the declaring type of this type, or
+     * null if this type does not represent a non-package-level-type.
+     * 
+     * <strong>Warning</strong>:  This is guaranteed to work for all member types.
+     * For anonymous/local types, the only guarantee is given in JLS 13.1, where
+     * it guarantees that if you call getDeclaringType() repeatedly, you will eventually
+     * get the top-level class, but it does not say anything about classes in between.
+     *
+     * @return the declaring TypeX object, or null.
+     */
+    public ResolvedTypeX getDeclaringType() {
+    	if (isArray()) return null;
+		String name = getName();
+		int lastDollar = name.lastIndexOf('$');
+		while (lastDollar != -1) {
+			ResolvedTypeX ret = world.resolve(TypeX.forName(name.substring(0, lastDollar)), true);
+			if (ret != ResolvedTypeX.MISSING) return ret;
+			lastDollar = name.lastIndexOf('$', lastDollar-1);
+		}
+		return null;
+    }
+	
 	
 	public static boolean isVisible(int modifiers, ResolvedTypeX targetType, ResolvedTypeX fromType) {
 		//System.err.println("mod: " + modifiers + ", " + targetType + " and " + fromType);
@@ -804,7 +822,7 @@ public abstract class ResolvedTypeX extends TypeX {
 		if (Modifier.isPublic(modifiers)) {
 			return true;
 		} else if (Modifier.isPrivate(modifiers)) {
-			return getOutermostType(targetType).equals(getOutermostType(fromType));
+			return targetType.getOutermostType().equals(fromType.getOutermostType());
 		} else if (Modifier.isProtected(modifiers)) {
 			return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType);
 		} else { // package-visible
diff --git a/weaver/src/org/aspectj/weaver/TypeX.java b/weaver/src/org/aspectj/weaver/TypeX.java
index 6b1443be0..f5bab0db3 100644
--- a/weaver/src/org/aspectj/weaver/TypeX.java
+++ b/weaver/src/org/aspectj/weaver/TypeX.java
@@ -249,26 +249,23 @@ public class TypeX {
     public final boolean isArray() {
         return signature.startsWith("[");
     }
-
+    
     /**
-     * Returns a TypeX object representing the declaring type of this type, or
-     * null if this type does not represent a non-package-level-type.
+     * Returns a TypeX object representing the effective outermost enclosing type
+     * for a name type.  For all other types, this will return the type itself.
      * 
-     * <strong>Warning</strong>:  This is guaranteed to work for all member types.
-     * For anonymous/local types, the only guarantee is given in JLS 13.1, where
-     * it guarantees that if you call getDeclaringType() repeatedly, you will eventually
-     * get the top-level class, but it does not say anything about classes in between.
-     *
-     * @return the declaring TypeX object, or null.
+     * The only guarantee is given in JLS 13.1 where code generated according to
+     * those rules will have type names that can be split apart in this way.
+     * @return the outermost enclosing TypeX object or this.
      */
-    public TypeX getDeclaringType() {
-    	if (isArray()) return null;
-		String name = getName();
-		int lastDollar = name.lastIndexOf('$');
-		if (lastDollar != -1) {
-        	return TypeX.forName(name.substring(0, lastDollar));
+    public TypeX getOutermostType() {
+    	if (isArray() || isPrimitive()) return this;
+		String sig = getSignature();
+		int dollar = sig.indexOf('$');
+		if (dollar != -1) {
+			return TypeX.forSignature(sig.substring(0, dollar) + ';');
 		} else {
-			return null;
+			return this;
 		}
     }
 
diff --git a/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java b/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
index 3a6db4bec..c3ddb5f19 100644
--- a/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/WithinPointcut.java
@@ -34,13 +34,14 @@ public class WithinPointcut extends Pointcut {
 	}
     
 	public FuzzyBoolean match(Shadow shadow) {
-		TypeX enclosingType = shadow.getEnclosingType();
+		ResolvedTypeX enclosingType = shadow.getIWorld().resolve(shadow.getEnclosingType());
+		//System.err.println("enclosingType: " + enclosingType);
 //		if (shadow.getKind() == Shadow.FieldSet) {
 //			System.err.println("within?" + type  + " matches " + enclosingType + " on " + shadow);
 //		}
 		
 		while (enclosingType != null) {
-			if (type.matchesStatically(shadow.getIWorld().resolve(enclosingType))) {
+			if (type.matchesStatically(enclosingType)) {
 				return FuzzyBoolean.YES;
 			}
 			enclosingType = enclosingType.getDeclaringType();
diff --git a/weaver/testsrc/org/aspectj/weaver/TypeXTestCase.java b/weaver/testsrc/org/aspectj/weaver/TypeXTestCase.java
index cc1af29c6..19b364792 100644
--- a/weaver/testsrc/org/aspectj/weaver/TypeXTestCase.java
+++ b/weaver/testsrc/org/aspectj/weaver/TypeXTestCase.java
@@ -58,8 +58,8 @@ public class TypeXTestCase extends TestCase {
     	TypeX t = TypeX.forName("java.util.Map$Entry");
     	assertEquals(t.getName(), "java.util.Map$Entry");
     	assertEquals(t.getSignature(), "Ljava/util/Map$Entry;");
-    	assertEquals(t.getDeclaringType(), TypeX.forName("java.util.Map"));
-    	assertNull(TypeX.forName("java.util.Map").getDeclaringType());
+    	assertEquals(t.getOutermostType(), TypeX.forName("java.util.Map"));
+    	assertEquals(TypeX.forName("java.util.Map").getOutermostType(), TypeX.forName("java.util.Map"));
     }
 
     private void isPrimitiveTest(TypeX[] types, boolean[] isPrimitives) {
-- 
2.39.5