251 lines
10 KiB
Java
251 lines
10 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2018, 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
|
||
|
|
* particular file as subject to the "Classpath" exception as provided
|
||
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
||
|
|
*
|
||
|
|
* 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.
|
||
|
|
*/
|
||
|
|
package java.lang.constant;
|
||
|
|
|
||
|
|
import java.lang.invoke.MethodHandle;
|
||
|
|
import java.lang.invoke.MethodHandleInfo;
|
||
|
|
import java.util.OptionalInt;
|
||
|
|
import java.util.stream.Stream;
|
||
|
|
|
||
|
|
import jdk.internal.vm.annotation.Stable;
|
||
|
|
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_getField;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_getStatic;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_invokeInterface;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_invokeSpecial;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_invokeStatic;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_invokeVirtual;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_newInvokeSpecial;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_putField;
|
||
|
|
import static java.lang.invoke.MethodHandleInfo.REF_putStatic;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A <a href="package-summary.html#nominal">nominal descriptor</a> for a direct
|
||
|
|
* {@link MethodHandle}. A {@linkplain DirectMethodHandleDesc} corresponds to
|
||
|
|
* a {@code Constant_MethodHandle_info} entry in the constant pool of a classfile.
|
||
|
|
*
|
||
|
|
* @since 12
|
||
|
|
*/
|
||
|
|
public sealed interface DirectMethodHandleDesc
|
||
|
|
extends MethodHandleDesc
|
||
|
|
permits DirectMethodHandleDescImpl {
|
||
|
|
/**
|
||
|
|
* Kinds of method handles that can be described with {@linkplain DirectMethodHandleDesc}.
|
||
|
|
*
|
||
|
|
* @since 12
|
||
|
|
*/
|
||
|
|
enum Kind {
|
||
|
|
/** A method handle for a method invoked as with {@code invokestatic} */
|
||
|
|
STATIC(REF_invokeStatic),
|
||
|
|
/** A method handle for a method invoked as with {@code invokestatic} */
|
||
|
|
INTERFACE_STATIC(REF_invokeStatic, true),
|
||
|
|
/** A method handle for a method invoked as with {@code invokevirtual} */
|
||
|
|
VIRTUAL(REF_invokeVirtual),
|
||
|
|
/** A method handle for a method invoked as with {@code invokeinterface} */
|
||
|
|
INTERFACE_VIRTUAL(REF_invokeInterface, true),
|
||
|
|
/** A method handle for a method invoked as with {@code invokespecial} */
|
||
|
|
SPECIAL(REF_invokeSpecial),
|
||
|
|
/** A method handle for an interface method invoked as with {@code invokespecial} */
|
||
|
|
INTERFACE_SPECIAL(REF_invokeSpecial, true),
|
||
|
|
/** A method handle for a constructor */
|
||
|
|
CONSTRUCTOR(REF_newInvokeSpecial),
|
||
|
|
/** A method handle for a read accessor for an instance field */
|
||
|
|
GETTER(REF_getField),
|
||
|
|
/** A method handle for a write accessor for an instance field */
|
||
|
|
SETTER(REF_putField),
|
||
|
|
/** A method handle for a read accessor for a static field */
|
||
|
|
STATIC_GETTER(REF_getStatic),
|
||
|
|
/** A method handle for a write accessor for a static field */
|
||
|
|
STATIC_SETTER(REF_putStatic);
|
||
|
|
|
||
|
|
/** The corresponding {@code refKind} value for this kind of method handle,
|
||
|
|
* as defined by {@link MethodHandleInfo}
|
||
|
|
*/
|
||
|
|
public final int refKind;
|
||
|
|
|
||
|
|
/** Is this an interface
|
||
|
|
*/
|
||
|
|
public final boolean isInterface;
|
||
|
|
Kind(int refKind) {
|
||
|
|
this(refKind, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
Kind(int refKind, boolean isInterface) { this.refKind = refKind; this.isInterface = isInterface; }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the enumeration member with the given {@code refKind} field.
|
||
|
|
* Behaves as if {@code valueOf(refKind, false)}. As a special case,
|
||
|
|
* if {@code refKind} is {@code REF_invokeInterface} (9) then the
|
||
|
|
* {@code isInterface} field will be true.
|
||
|
|
*
|
||
|
|
* @param refKind refKind of desired member
|
||
|
|
* @return the matching enumeration member
|
||
|
|
* @throws IllegalArgumentException if there is no such member
|
||
|
|
*/
|
||
|
|
public static Kind valueOf(int refKind) {
|
||
|
|
return valueOf(refKind, refKind == REF_invokeInterface);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the enumeration member with the given the {@code refKind} and
|
||
|
|
* {@code isInterface} arguments.
|
||
|
|
* For most values of {@code refKind} there is an exact match regardless of the value of {@code isInterface}.
|
||
|
|
* These are:
|
||
|
|
* <UL>
|
||
|
|
* <LI>{@code REF_invokeVirtual} which matches to {@code VIRTUAL}
|
||
|
|
* <LI>{@code REF_invokeInterface} which matches to {@code INTERFACE_VIRTUAL}
|
||
|
|
* <LI>{@code REF_newInvokeSpecial} which matches to {@code CONSTRUCTOR}
|
||
|
|
* <LI>{@code REF_getField} which matches to {@code GETTER}
|
||
|
|
* <LI>{@code REF_putField} which matches to {@code SETTER}
|
||
|
|
* <LI>{@code REF_getStatic} which matches to {@code STATIC_GETTER}
|
||
|
|
* <LI>{@code REF_putStatic} which matches to {@code STATIC_SETTER}
|
||
|
|
* </UL>
|
||
|
|
* As for the rest, the returned kind will depend on the value (false or true accordingly) of {@code isInterface}:
|
||
|
|
* <UL>
|
||
|
|
* <LI>{@code REF_invokeStatic} which matches to {@code STATIC} or {@code INTERFACE_STATIC}
|
||
|
|
* <LI>{@code REF_invokeSpecial} which matches to {@code SPECIAL} or {@code INTERFACE_SPECIAL}
|
||
|
|
* </UL>
|
||
|
|
* @param refKind refKind of desired member
|
||
|
|
* @param isInterface whether desired member is for interface methods
|
||
|
|
* @return the matching enumeration member
|
||
|
|
* @throws IllegalArgumentException if there is no such member
|
||
|
|
*/
|
||
|
|
public static Kind valueOf(int refKind, boolean isInterface) {
|
||
|
|
int i = tableIndex(refKind, isInterface);
|
||
|
|
if (i >= 2 && i < TABLE.length) {
|
||
|
|
return TABLE[i];
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException(String.format("refKind=%d isInterface=%s", refKind, isInterface));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int tableIndex(int refKind, boolean isInterface) {
|
||
|
|
if (refKind < 0) return refKind;
|
||
|
|
return (refKind * 2) + (isInterface ? 1 : 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final @Stable Kind[] TABLE;
|
||
|
|
|
||
|
|
static {
|
||
|
|
// Pack the static table.
|
||
|
|
int max = 0;
|
||
|
|
for (Kind k : values())
|
||
|
|
max = Math.max(max, tableIndex(k.refKind, true));
|
||
|
|
|
||
|
|
TABLE = new Kind[max+1];
|
||
|
|
for (Kind kind : values()) {
|
||
|
|
int i = tableIndex(kind.refKind, kind.isInterface);
|
||
|
|
if (i >= TABLE.length || TABLE[i] != null)
|
||
|
|
throw new AssertionError("TABLE entry for " + kind);
|
||
|
|
TABLE[i] = kind;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Pack in some aliases also.
|
||
|
|
int ii = tableIndex(REF_invokeInterface, false);
|
||
|
|
if (TABLE[ii] != null)
|
||
|
|
throw new AssertionError("TABLE entry for (invokeInterface, false) used by " + TABLE[ii]);
|
||
|
|
TABLE[ii] = INTERFACE_VIRTUAL;
|
||
|
|
|
||
|
|
for (Kind kind : values()) {
|
||
|
|
if (!kind.isInterface) {
|
||
|
|
// Add extra cache entry to alias the isInterface case.
|
||
|
|
// For example, (REF_getStatic, X) will produce STATIC_GETTER
|
||
|
|
// for either truth value of X.
|
||
|
|
int i = tableIndex(kind.refKind, true);
|
||
|
|
if (TABLE[i] == null) {
|
||
|
|
TABLE[i] = kind;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Does this {@code Kind} correspond to a virtual method invocation?
|
||
|
|
*
|
||
|
|
* @return if this {@code Kind} corresponds to a virtual method invocation
|
||
|
|
*/
|
||
|
|
boolean isVirtualMethod() {
|
||
|
|
switch (this) {
|
||
|
|
case VIRTUAL:
|
||
|
|
case SPECIAL:
|
||
|
|
case INTERFACE_VIRTUAL:
|
||
|
|
case INTERFACE_SPECIAL:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the {@code kind} of the method handle described by this nominal
|
||
|
|
* descriptor.
|
||
|
|
*
|
||
|
|
* @return the {@link Kind}
|
||
|
|
*/
|
||
|
|
Kind kind();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the {@code refKind} of the method handle described by this nominal
|
||
|
|
* reference, as defined by {@link MethodHandleInfo}.
|
||
|
|
*
|
||
|
|
* @return the reference kind
|
||
|
|
*/
|
||
|
|
int refKind();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Indicates if the method is declared by an interface
|
||
|
|
*
|
||
|
|
* @return true if the method is declared by an interface
|
||
|
|
*/
|
||
|
|
boolean isOwnerInterface();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a {@link ClassDesc} describing the class declaring the
|
||
|
|
* method or field described by this nominal descriptor.
|
||
|
|
*
|
||
|
|
* @return the class declaring the method or field
|
||
|
|
*/
|
||
|
|
ClassDesc owner();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the name of the method or field described by this nominal descriptor.
|
||
|
|
* For constructors, returns the reserved name {@code "<init>"}.
|
||
|
|
*
|
||
|
|
* @return the name of the method or field
|
||
|
|
*/
|
||
|
|
String methodName();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the lookup descriptor of the method handle described by this descriptor,
|
||
|
|
* after adjusting for the invocation mode. This will correspond to either
|
||
|
|
* a method type descriptor string (for methods and constructors), or a field
|
||
|
|
* descriptor string (for field access method handles). The lookup descriptor
|
||
|
|
* string is in the same format as accepted by {@link MethodHandleDesc#of(Kind, ClassDesc, String, String)}.
|
||
|
|
*
|
||
|
|
* @return the lookup descriptor string
|
||
|
|
*/
|
||
|
|
String lookupDescriptor();
|
||
|
|
}
|