Fix Class.getEnclosingClass for anonymous classes declared in <clinit> methods

(cherry picked from commit b9be313bdc257089534f738ff8e1e5ad4de3d25e)

Bug: 11245138
Related bug: https://code.google.com/p/android/issues/detail?id=61003

Change-Id: I5cc1db6ca6628b845409d7a6ea864da5f625fdc3

3 files changed, 51 insertions, 5 deletions

diff --git a/libart/src/main/java/java/lang/Class.java b/libart/src/main/java/java/lang/Class.java
index d4f5cbd35..eda2b5c9e 100644
--- a/libart/src/main/java/java/lang/Class.java
+++ b/libart/src/main/java/java/lang/Class.java
@@ -958,7 +958,7 @@ public final class Class<T> implements Serializable, AnnotatedElement, GenericDe
         if (AnnotationAccess.isAnonymousClass(this)) {
             return null;
         }
-        return AnnotationAccess.getDeclaringClass(this);
+        return AnnotationAccess.getEnclosingClass(this);
     }
 
     /**
@@ -973,9 +973,10 @@ public final class Class<T> implements Serializable, AnnotatedElement, GenericDe
             return declaringClass;
         }
         AccessibleObject member = AnnotationAccess.getEnclosingMethodOrConstructor(this);
-        return member != null
-                ? ((Member) member).getDeclaringClass()
-                : null;
+        if (member != null)  {
+            return ((Member) member).getDeclaringClass();
+        }
+        return AnnotationAccess.getEnclosingClass(this);
     }
 
     /**
diff --git a/luni/src/main/java/libcore/reflect/AnnotationAccess.java b/luni/src/main/java/libcore/reflect/AnnotationAccess.java
index 064151eb7..c2b54ce85 100644
--- a/luni/src/main/java/libcore/reflect/AnnotationAccess.java
+++ b/luni/src/main/java/libcore/reflect/AnnotationAccess.java
@@ -384,7 +384,7 @@ public final class AnnotationAccess {
      * Returns the class of which {@code c} is a direct member. If {@code c} is
      * defined in a method or constructor, this is not transitive.
      */
-    public static Class<?> getDeclaringClass(Class<?> c) {
+    public static Class<?> getEnclosingClass(Class<?> c) {
         /*
          * public class Bar {
          *   @EnclosingClass(value=Bar)
diff --git a/luni/src/test/java/libcore/java/lang/reflect/AnnotationsTest.java b/luni/src/test/java/libcore/java/lang/reflect/AnnotationsTest.java
index 95fe106c1..6eb31f8c3 100644
--- a/luni/src/test/java/libcore/java/lang/reflect/AnnotationsTest.java
+++ b/luni/src/test/java/libcore/java/lang/reflect/AnnotationsTest.java
@@ -94,6 +94,51 @@ public final class AnnotationsTest extends TestCase {
 
     public void testEnclosingClass() {
         assertEquals(AnnotationsTest.class, Foo.class.getEnclosingClass());
+    }
+
+    public void testGetDeclaringClass() {
+        assertNull(AnnotationsTest.class.getDeclaringClass());
+        assertEquals(AnnotationsTest.class, Foo.class.getDeclaringClass());
+        assertEquals(AnnotationsTest.class, HasMemberClassesInterface.class.getDeclaringClass());
+        assertEquals(HasMemberClassesInterface.class,
+                HasMemberClassesInterface.D.class.getDeclaringClass());
+    }
+
+    public void testGetEnclosingClassIsTransitiveForClassesDefinedInAMethod() {
+        class C {}
+        assertEquals(AnnotationsTest.class, C.class.getEnclosingClass());
+    }
+
+    public void testGetDeclaringClassIsNotTransitiveForClassesDefinedInAMethod() {
+        class C {}
+        assertEquals(null, C.class.getDeclaringClass());
+    }
+
+    public void testGetEnclosingMethodIsNotTransitive() {
+        class C {
+            class D {}
+        }
+        assertEquals(null, C.D.class.getEnclosingMethod());
+    }
+
+    public void testStaticFieldAnonymousClass() {
+        // The class declared in the <clinit> is enclosed by the <clinit>'s class.
+        // http://b/11245138b
+        assertEquals(AnnotationsTest.class, staticAnonymous.getClass().getEnclosingClass());
+        // However, because it is anonymous, it has no delcaring class.
+        // https://code.google.com/p/android/issues/detail?id=61003
+        assertNull(staticAnonymous.getClass().getDeclaringClass());
+        // Because the class is declared in <clinit> which is not exposed through reflection,
+        // it has no enclosing method or constructor.
+        assertNull(staticAnonymous.getClass().getEnclosingMethod());
+        assertNull(staticAnonymous.getClass().getEnclosingConstructor());
+    }
+
+    public void testGetEnclosingMethodOfTopLevelClass() {
+        assertNull(AnnotationsTest.class.getEnclosingMethod());
+    }
+
+    public void testGetEnclosingConstructorOfTopLevelClass() {
         assertNull(AnnotationsTest.class.getEnclosingConstructor());
         assertNull(AnnotationsTest.class.getEnclosingMethod());
     }