add ResolvedJavaType#getEnclosingMethod and ResolvedJavaType#getEnclosingConstructor

Author: zapster

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotJDKReflection.java

@@ -27,6 +27,7 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -103,6 +104,26 @@ HotSpotResolvedObjectType getEnclosingClass(HotSpotResolvedObjectTypeImpl holder
         return (HotSpotResolvedObjectType) runtime().fromClass(javaMirror.getEnclosingClass());
     }
 
+    @Override
+    HotSpotResolvedJavaMethod getEnclosingMethod(HotSpotResolvedObjectTypeImpl holder) {
+        Class<?> javaMirror = getMirror(holder);
+        Method enclosingMethod = javaMirror.getEnclosingMethod();
+        if (enclosingMethod == null) {
+            return null;
+        }
+        return compilerToVM().asResolvedJavaMethod(enclosingMethod);
+    }
+
+    @Override
+    HotSpotResolvedJavaMethod getEnclosingConstructor(HotSpotResolvedObjectTypeImpl holder) {
+        Class<?> javaMirror = getMirror(holder);
+        Constructor<?> enclosingMethod = javaMirror.getEnclosingConstructor();
+        if (enclosingMethod == null) {
+            return null;
+        }
+        return compilerToVM().asResolvedJavaMethod(enclosingMethod);
+    }
+
     @Override
     boolean equals(HotSpotObjectConstantImpl a, HotSpotObjectConstantImpl b) {
         return resolveObject(a) == resolveObject(b) && a.isCompressed() == b.isCompressed();

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotJVMCIReflection.java

@@ -50,6 +50,10 @@ abstract class HotSpotJVMCIReflection {
 
     abstract HotSpotResolvedObjectType getEnclosingClass(HotSpotResolvedObjectTypeImpl holder);
 
+    abstract HotSpotResolvedJavaMethod getEnclosingMethod(HotSpotResolvedObjectTypeImpl holder);
+
+    abstract HotSpotResolvedJavaMethod getEnclosingConstructor(HotSpotResolvedObjectTypeImpl holder);
+
     abstract boolean equals(HotSpotObjectConstantImpl hotSpotResolvedJavaType, HotSpotObjectConstantImpl that);
 
     abstract ResolvedJavaMethod.Parameter[] getParameters(HotSpotResolvedJavaMethodImpl javaMethod);

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java

@@ -1102,6 +1102,16 @@ public HotSpotResolvedObjectType getEnclosingType() {
         return runtime().reflection.getEnclosingClass(this);
     }
 
+    @Override
+    public ResolvedJavaMethod getEnclosingMethod() {
+        return runtime().reflection.getEnclosingMethod(this);
+    }
+
+    @Override
+    public ResolvedJavaMethod getEnclosingConstructor() {
+        return runtime().reflection.getEnclosingConstructor(this);
+    }
+
     @Override
     public ResolvedJavaMethod[] getDeclaredConstructors() {
         link();

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotResolvedPrimitiveType.java

@@ -302,6 +302,16 @@ public ResolvedJavaType getEnclosingType() {
         return null;
     }
 
+    @Override
+    public ResolvedJavaMethod getEnclosingMethod() {
+        return null;
+    }
+
+    @Override
+    public ResolvedJavaMethod getEnclosingConstructor() {
+        return null;
+    }
+
     @Override
     public ResolvedJavaMethod[] getDeclaredConstructors() {
         return new ResolvedJavaMethod[0];

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/SharedLibraryJVMCIReflection.java

@@ -71,6 +71,16 @@ HotSpotResolvedObjectType getEnclosingClass(HotSpotResolvedObjectTypeImpl holder
         throw new HotSpotJVMCIUnsupportedOperationError("requires a call Class.getEnclosingClass()");
     }
 
+    @Override
+    HotSpotResolvedJavaMethod getEnclosingMethod(HotSpotResolvedObjectTypeImpl holder) {
+        throw new HotSpotJVMCIUnsupportedOperationError("requires a call Class.getEnclosingMethod()");
+    }
+
+    @Override
+    HotSpotResolvedJavaMethod getEnclosingConstructor(HotSpotResolvedObjectTypeImpl holder) {
+        throw new HotSpotJVMCIUnsupportedOperationError("requires a call Class.getEnclosingConstructor()");
+    }
+
     @Override
     boolean equals(HotSpotObjectConstantImpl x, HotSpotObjectConstantImpl y) {
         if (x == y) {

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ResolvedJavaType.java

@@ -391,6 +391,38 @@ default ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method, Reso
      */
     ResolvedJavaType getEnclosingType();
 
+    /**
+     * Returns a {@link ResolvedJavaMethod} representing the immediately enclosing
+     * method of the underlying type, if this type represents a local or anonymous
+     * class within a method. Returns {@code null} otherwise.
+     *
+     * In particular, this method returns {@code null} if the underlying
+     * type is a local or anonymous class immediately enclosed by a class or
+     * interface declaration, instance initializer or static initializer.
+     *
+     * @return the immediately enclosing method of the underlying class, if
+     *     this type is a local or anonymous class; otherwise {@code null}.
+     *
+     * @see Class#getEnclosingMethod()
+     */
+    ResolvedJavaMethod getEnclosingMethod();
+
+    /**
+     * Returns a {@link ResolvedJavaMethod} representing the immediately enclosing
+     * constructor of the underlying type, if this type represents a local or anonymous
+     * class within a method. Returns {@code null} otherwise.
+     *
+     * In particular, this method returns {@code null} if the underlying
+     * type is a local or anonymous class immediately enclosed by a class or
+     * interface declaration, instance initializer or static initializer.
+     *
+     * @return the immediately enclosing constructor of the underlying class, if
+     *     this type is a local or anonymous class; otherwise {@code null}.
+     *
+     * @see Class#getEnclosingConstructor()
+     */
+    ResolvedJavaMethod getEnclosingConstructor();
+
     /**
      * Returns an array reflecting all the constructors declared by this type. This method is
      * similar to {@link Class#getDeclaredConstructors()} in terms of returned constructors. Calling

test/hotspot/jtreg/compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java

@@ -751,6 +751,72 @@ private void assertGetPermittedSubclasses(Class<?> clazz) {
         }
     }
 
+    @Test
+    public void getEnclosingMethodTest() {
+        // no anonymous class -> expected null
+        Object obj0 = new Object();
+        testEnclosingMethod(obj0.getClass(), false);
+
+        // anonymous class -> not null
+        Object obj1 = new Object() {};
+        testEnclosingMethod(obj1.getClass(), true);
+
+        // local class -> not null
+        class Foo {};
+        testEnclosingMethod(Foo.class, true);
+    }
+
+    private static void testEnclosingMethod(Class<?> clazz, boolean isEnclosed) {
+        ResolvedJavaType type = metaAccess.lookupJavaType(clazz);
+        Method expected = clazz.getEnclosingMethod();
+        ResolvedJavaMethod actual = type.getEnclosingMethod();
+        if (expected == null) {
+            assertFalse(isEnclosed);
+            assertNull(actual);
+        } else {
+            assertTrue(isEnclosed);
+            assertEquals(metaAccess.lookupJavaMethod(expected), actual);
+        }
+    }
+
+    @Test
+    public void getEnclosingConstructorTest() {
+        class Bar {
+            final Object obj0;
+            final Object obj1;
+            final Object obj2;
+
+            Bar() {
+                // no anonymous class -> expected null
+                obj0 = new Object();
+
+                // anonymous class -> not null
+                obj1 = new Object() {};
+
+                // local class -> not null
+                class Foo {};
+                obj2 = new Foo();
+            }
+        }
+        Bar bar = new Bar();
+        testEnclosingConstructor(bar.obj0.getClass(), false);
+        testEnclosingConstructor(bar.obj1.getClass(), true);
+        testEnclosingConstructor(bar.obj2.getClass(), true);
+    }
+
+    private static void testEnclosingConstructor(Class<?> clazz, boolean isEnclosed) {
+        ResolvedJavaType type = metaAccess.lookupJavaType(clazz);
+        Constructor expected = clazz.getEnclosingConstructor();
+        ResolvedJavaMethod actual = type.getEnclosingConstructor();
+        if (expected == null) {
+            assertFalse(isEnclosed);
+            assertNull(actual);
+        } else {
+            assertTrue(isEnclosed);
+            assertEquals(metaAccess.lookupJavaMethod(expected), actual);
+        }
+    }
+
     static class Declarations {
 
         final Method implementation;