--- a/src/java.base/share/classes/java/lang/invoke/MethodType.java Thu Oct 17 20:27:44 2019 +0100
+++ b/src/java.base/share/classes/java/lang/invoke/MethodType.java Thu Oct 17 20:53:35 2019 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 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
@@ -46,9 +46,11 @@
import sun.invoke.util.BytecodeDescriptor;
import sun.invoke.util.VerifyType;
import sun.invoke.util.Wrapper;
+import sun.security.util.SecurityConstants;
import static java.lang.invoke.MethodHandleStatics.UNSAFE;
import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
+import static java.lang.invoke.MethodType.fromDescriptor;
/**
* A method type represents the arguments and return type accepted and
@@ -104,6 +106,7 @@
implements Constable,
TypeDescriptor.OfMethod<Class<?>, MethodType>,
java.io.Serializable {
+ @java.io.Serial
private static final long serialVersionUID = 292L; // {rtype, {ptype...}}
// The rtype and ptypes fields define the structural identity of the method type:
@@ -925,8 +928,8 @@
return false;
return true;
}
- if ((oldForm.primitiveParameterCount() == 0 && oldForm.erasedType == this) ||
- (newForm.primitiveParameterCount() == 0 && newForm.erasedType == newType)) {
+ if ((!oldForm.hasPrimitives() && oldForm.erasedType == this) ||
+ (!newForm.hasPrimitives() && newForm.erasedType == newType)) {
// Somewhat complicated test to avoid a loop of 2 or more trips.
// If either type has only Object parameters, we know we can convert.
assert(canConvertParameters(srcTypes, dstTypes));
@@ -1072,55 +1075,11 @@
return inv;
}
- /** Reports the number of JVM stack slots which carry all parameters including and after
- * the given position, which must be in the range of 0 to
- * {@code parameterCount} inclusive. Successive parameters are
- * more shallowly stacked, and parameters are indexed in the bytecodes
- * according to their trailing edge. Thus, to obtain the depth
- * in the outgoing call stack of parameter {@code N}, obtain
- * the {@code parameterSlotDepth} of its trailing edge
- * at position {@code N+1}.
- * <p>
- * Parameters of type {@code long} and {@code double} occupy
- * two stack slots (for historical reasons) and all others occupy one.
- * Therefore, the number returned is the number of arguments
- * <em>including</em> and <em>after</em> the given parameter,
- * <em>plus</em> the number of long or double arguments
- * at or after the argument for the given parameter.
- * <p>
- * This method is included for the benefit of applications that must
- * generate bytecodes that process method handles and invokedynamic.
- * @param num an index (zero-based, inclusive) within the parameter types
- * @return the index of the (shallowest) JVM stack slot transmitting the
- * given parameter
- * @throws IllegalArgumentException if {@code num} is negative or greater than {@code parameterCount()}
- */
- /*non-public*/ int parameterSlotDepth(int num) {
- if (num < 0 || num > ptypes.length)
- parameterType(num); // force a range check
- return form.parameterToArgSlot(num-1);
- }
-
- /** Reports the number of JVM stack slots required to receive a return value
- * from a method of this type.
- * If the {@link #returnType() return type} is void, it will be zero,
- * else if the return type is long or double, it will be two, else one.
- * <p>
- * This method is included for the benefit of applications that must
- * generate bytecodes that process method handles and invokedynamic.
- * @return the number of JVM stack slots (0, 1, or 2) for this type's return value
- * Will be removed for PFD.
- */
- /*non-public*/ int returnSlotCount() {
- return form.returnSlotCount();
- }
-
/**
* Finds or creates an instance of a method type, given the spelling of its bytecode descriptor.
* Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[]) methodType}.
- * Any class or interface name embedded in the descriptor string
- * will be resolved by calling {@link ClassLoader#loadClass(java.lang.String)}
- * on the given loader (or if it is null, on the system class loader).
+ * Any class or interface name embedded in the descriptor string will be
+ * resolved by the given loader (or if it is null, on the system class loader).
* <p>
* Note that it is possible to encounter method types which cannot be
* constructed by this method, because their component types are
@@ -1134,10 +1093,19 @@
* @throws NullPointerException if the string is null
* @throws IllegalArgumentException if the string is not well-formed
* @throws TypeNotPresentException if a named type cannot be found
+ * @throws SecurityException if the security manager is present and
+ * {@code loader} is {@code null} and the caller does not have the
+ * {@link RuntimePermission}{@code ("getClassLoader")}
*/
public static MethodType fromMethodDescriptorString(String descriptor, ClassLoader loader)
throws IllegalArgumentException, TypeNotPresentException
{
+ if (loader == null) {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
+ }
+ }
return fromDescriptor(descriptor,
(loader == null) ? ClassLoader.getSystemClassLoader() : loader);
}
@@ -1229,6 +1197,7 @@
/**
* There are no serializable fields for {@code MethodType}.
*/
+ @java.io.Serial
private static final java.io.ObjectStreamField[] serialPersistentFields = { };
/**
@@ -1251,6 +1220,7 @@
* @param s the stream to write the object to
* @throws java.io.IOException if there is a problem writing the object
*/
+ @java.io.Serial
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
s.defaultWriteObject(); // requires serialPersistentFields to be an empty array
s.writeObject(returnType());
@@ -1270,6 +1240,7 @@
* @see #readResolve
* @see #writeObject
*/
+ @java.io.Serial
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
// Assign temporary defaults in case this object escapes
MethodType_init(void.class, NO_PTYPES);
@@ -1309,6 +1280,7 @@
* after serialization.
* @return the fully initialized {@code MethodType} object
*/
+ @java.io.Serial
private Object readResolve() {
// Do not use a trusted path for deserialization:
// return makeImpl(rtype, ptypes, true);