jdk-sandbox: comparison src/java.base/share/classes/java/lang/invoke/MethodType.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 import jdk.internal.vm.annotation.Stable;
 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
 * returned by a method handle, or the arguments and return type passed
 * and expected  by a method handle caller.  Method types must be properly
 public final
 class MethodType
 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:
 private final @Stable Class<?>   rtype;
 private final @Stable Class<?>[] ptypes;
 if (argc <= 1) {
 if (argc == 1 && !canConvert(srcTypes[0], dstTypes[0]))
 return false;
 return true;
 }
-if ((oldForm.primitiveParameterCount() == 0 && oldForm.erasedType == this) ||
+if ((!oldForm.hasPrimitives() && oldForm.erasedType == this) ||
-(newForm.primitiveParameterCount() == 0 && newForm.erasedType == newType)) {
+(!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));
 return true;
 }
 if (inv != null)  return inv;
 invokers = inv = new Invokers(this);
 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
+* Any class or interface name embedded in the descriptor string will be
-* will be resolved by calling {@link ClassLoader#loadClass(java.lang.String)}
+* resolved by the given loader (or if it is null, on the system class loader).
-* on 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
 * not all reachable from a common class loader.
 * <p>
 * @param loader the class loader in which to look up the types
 * @return a method type matching the bytecode-level type descriptor
 * @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);
 }
 /**
 /// Serialization.
 /**
 * There are no serializable fields for {@code MethodType}.
 */
+@java.io.Serial
 private static final java.io.ObjectStreamField[] serialPersistentFields = { };
 /**
 * Save the {@code MethodType} instance to a stream.
 *
 * For example, null values, or {@code void} parameter types,
 * will lead to exceptions during deserialization.
 * @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());
 s.writeObject(parameterArray());
 }
 * @throws java.io.IOException if there is a problem reading the object
 * @throws ClassNotFoundException if one of the component classes cannot be resolved
 * @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);
 s.defaultReadObject();  // requires serialPersistentFields to be an empty array
 /**
 * Resolves and initializes a {@code MethodType} object
 * 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);
 // Verify all operands, and make sure ptypes is unshared:
 try {

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 52914	4fa75d8ad418
child 58679	9c3209ff7550