# HG changeset patch
# User mchung
# Date 1572378723 25200
# Node ID 67a3f50b14ae7777f3807081ac905bfd9b5d599d
# Parent  f9ac726ab347285ad6df0c03c5d401b544af9a0e
8173975: Lookup::in should not allow target class be primitive or array class
Reviewed-by: alanb

diff -r f9ac726ab347 -r 67a3f50b14ae src/java.base/share/classes/java/lang/invoke/MethodHandles.java
--- a/src/java.base/share/classes/java/lang/invoke/MethodHandles.java	Tue Oct 29 12:01:14 2019 -0700
+++ b/src/java.base/share/classes/java/lang/invoke/MethodHandles.java	Tue Oct 29 12:52:03 2019 -0700
@@ -203,7 +203,7 @@
      * @param targetClass the target class
      * @param caller the caller lookup object
      * @return a lookup object for the target class, with private access
-     * @throws IllegalArgumentException if {@code targetClass} is a primitive type or array class
+     * @throws IllegalArgumentException if {@code targetClass} is a primitive type or void or array class
      * @throws NullPointerException if {@code targetClass} or {@code caller} is {@code null}
      * @throws SecurityException if denied by the security manager
      * @throws IllegalAccessException if any of the other access checks specified above fails
@@ -1385,7 +1385,7 @@
         private Lookup(Class<?> lookupClass, Class<?> prevLookupClass, int allowedModes) {
             assert prevLookupClass == null || ((allowedModes & MODULE) == 0
                     && prevLookupClass.getModule() != lookupClass.getModule());
-
+            assert !lookupClass.isArray() && !lookupClass.isPrimitive();
             this.lookupClass = lookupClass;
             this.prevLookupClass = prevLookupClass;
             this.allowedModes = allowedModes;
@@ -1443,6 +1443,7 @@
          * @param requestedLookupClass the desired lookup class for the new lookup object
          * @return a lookup object which reports the desired lookup class, or the same object
          * if there is no change
+         * @throws IllegalArgumentException if {@code requestedLookupClass} is a primitive type or void or array class
          * @throws NullPointerException if the argument is null
          *
          * @revised 9
@@ -1452,6 +1453,11 @@
          */
         public Lookup in(Class<?> requestedLookupClass) {
             Objects.requireNonNull(requestedLookupClass);
+            if (requestedLookupClass.isPrimitive())
+                throw new IllegalArgumentException(requestedLookupClass + " is a primitive class");
+            if (requestedLookupClass.isArray())
+                throw new IllegalArgumentException(requestedLookupClass + " is an array class");
+
             if (allowedModes == TRUSTED)  // IMPL_LOOKUP can make any lookup at all
                 return new Lookup(requestedLookupClass, null, FULL_POWER_MODES);
             if (requestedLookupClass == this.lookupClass)
diff -r f9ac726ab347 -r 67a3f50b14ae test/jdk/java/lang/invoke/lookup/LookupClassTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/lang/invoke/lookup/LookupClassTest.java	Tue Oct 29 12:52:03 2019 -0700
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8173975
+ * @summary Lookup::in throws IAE if the target class is a primitive class or array class
+ * @run testng/othervm LookupClassTest
+ */
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+import static org.testng.Assert.*;
+
+public class LookupClassTest {
+    private static final LookupClassTest[] ARRAY = new LookupClassTest[0];
+    @BeforeTest
+    public void test() {
+        assertTrue(ARRAY.getClass().isArray());
+        assertSamePackage(MethodHandles.lookup(), ARRAY.getClass());
+        assertSamePackage(MethodHandles.publicLookup(), int.class);
+    }
+
+    private void assertSamePackage(Lookup lookup, Class<?> targetClass) {
+        assertEquals(lookup.lookupClass().getPackageName(), targetClass.getPackageName());
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void arrayLookupClass() {
+        Lookup lookup = MethodHandles.lookup();
+        lookup.in(ARRAY.getClass());
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void primitiveLookupClass() {
+        Lookup lookup = MethodHandles.publicLookup();
+        lookup.in(int.class);
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void voidLookupClass() {
+        Lookup lookup = MethodHandles.publicLookup();
+        lookup.in(void.class);
+    }
+}