From b229be5962cb737b6601ac11a0e2d76cd6a59e9b Mon Sep 17 00:00:00 2001 From: Theresa Mammarella Date: Thu, 13 Dec 2018 08:39:24 -0500 Subject: [PATCH] Stubs for Constants API (jep 334) Signed-off-by: Theresa Mammarella --- .../share/classes/java/lang/Class.java | 22 ++++++++-- .../share/classes/java/lang/String.java | 26 ++++++++++- .../java/lang/invoke/MethodHandle.java | 20 ++++++++- .../classes/java/lang/invoke/MethodType.java | 35 ++++++++++++--- .../classes/java/lang/invoke/VarHandle.java | 44 +++++++++++++++++-- 5 files changed, 133 insertions(+), 14 deletions(-) diff --git a/jcl/src/java.base/share/classes/java/lang/Class.java b/jcl/src/java.base/share/classes/java/lang/Class.java index 1963dd0f3b..e0f3fee3eb 100644 --- a/jcl/src/java.base/share/classes/java/lang/Class.java +++ b/jcl/src/java.base/share/classes/java/lang/Class.java @@ -50,6 +50,10 @@ import java.security.PrivilegedExceptionAction; import java.security.PrivilegedAction; import java.lang.ref.*; +/*[IF Java12]*/ +import java.lang.constant.ClassDesc; +import java.lang.constant.Constable; +/*[ENDIF]*/ import sun.reflect.generics.repository.ClassRepository; import sun.reflect.generics.factory.CoreReflectionFactory; @@ -130,7 +134,11 @@ * @author OTI * @version initial */ -public final class Class implements java.io.Serializable, GenericDeclaration, Type { +public final class Class implements java.io.Serializable, GenericDeclaration, Type +/*[IF Java12]*/ + , Constable, TypeDescriptor, TypeDescriptor.OfField> +/*[ENDIF]*/ +{ private static final long serialVersionUID = 3206093459760846163L; private static ProtectionDomain AllPermissionsPD; private static final int SYNTHETIC = 0x1000; @@ -4554,11 +4562,19 @@ public Class[] getNestMembers() throws LinkageError, SecurityException { /*[IF Java12]*/ public Class arrayType() { - throw new UnsupportedOperationException("Stub for Java 12 compilation"); + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); + } + + public Class componentType() { + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); } public Optional describeConstable() { - throw new UnsupportedOperationException("Stub for Java 12 compilation"); + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); + } + + public String descriptorString() { + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); } /*[ENDIF] Java12 */ } diff --git a/jcl/src/java.base/share/classes/java/lang/String.java b/jcl/src/java.base/share/classes/java/lang/String.java index 820b2199e9..1cd54a58e4 100644 --- a/jcl/src/java.base/share/classes/java/lang/String.java +++ b/jcl/src/java.base/share/classes/java/lang/String.java @@ -36,6 +36,9 @@ import java.util.function.IntUnaryOperator; import java.util.Iterator; import java.nio.charset.Charset; +/*[IF Java12]*/ +import java.util.Optional; +/*[ENDIF]*/ import java.util.Spliterator; import java.util.stream.StreamSupport; @@ -50,6 +53,13 @@ import java.util.stream.Stream; /*[ENDIF] Java11*/ +/*[IF Java12]*/ +import java.lang.constant.Constable; +import java.lang.constant.ConstantDesc; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodHandles.Lookup; +/*[ENDIF]*/ + /** * Strings are objects which represent immutable arrays of characters. * @@ -58,7 +68,11 @@ * * @see StringBuffer */ -public final class String implements Serializable, Comparable, CharSequence { +public final class String implements Serializable, Comparable, CharSequence +/*[IF Java12]*/ + , Constable, ConstantDesc +/*[ENDIF]*/ +{ /* * Last character of String substitute in String.replaceAll(regex, substitute) can't be \ or $. @@ -8281,4 +8295,14 @@ public static String join(CharSequence delimiter, Iterable describeConstable() { + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); + } + + public String resolveConstantDesc(MethodHandles.Lookup lookup) { + throw new UnsupportedOperationException("Stub for Java 12 compilation (Jep334)"); + } +/*[ENDIF] Java12 */ } diff --git a/jcl/src/java.base/share/classes/java/lang/invoke/MethodHandle.java b/jcl/src/java.base/share/classes/java/lang/invoke/MethodHandle.java index 078738360d..50b5280f64 100644 --- a/jcl/src/java.base/share/classes/java/lang/invoke/MethodHandle.java +++ b/jcl/src/java.base/share/classes/java/lang/invoke/MethodHandle.java @@ -26,6 +26,10 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; +/*[IF Java12]*/ +import java.lang.constant.Constable; +import java.lang.constant.MethodHandleDesc; +/*[ENDIF]*/ import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Modifier; import java.security.AccessController; @@ -35,6 +39,9 @@ import java.util.List; import java.util.Objects; +/*[IF Java12]*/ +import java.util.Optional; +/*[ENDIF]*/ // {{{ JIT support import java.util.concurrent.ConcurrentHashMap; @@ -81,7 +88,11 @@ * @since 1.7 */ @VMCONSTANTPOOL_CLASS -public abstract class MethodHandle { +public abstract class MethodHandle +/*[IF Java12]*/ + implements Constable +/*[ENDIF]*/ +{ /* Ensure that these stay in sync with the MethodHandleInfo constants and VM constants in VM_MethodHandleKinds.h */ /* Order matters here - static and special are direct pointers */ static final byte KIND_BOUND = 0; @@ -724,6 +735,13 @@ public MethodHandle asFixedArity() { return this; } +/*[IF Java12]*/ + public Optional describeConstable() { + /* Jep334 */ + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } +/*[ENDIF]*/ + public MethodHandle bindTo(Object value) throws IllegalArgumentException, ClassCastException { /* * Check whether the first parameter has a reference type assignable from value. Note that MethodType.parameterType(0) will diff --git a/jcl/src/java.base/share/classes/java/lang/invoke/MethodType.java b/jcl/src/java.base/share/classes/java/lang/invoke/MethodType.java index a946327a90..3269876665 100644 --- a/jcl/src/java.base/share/classes/java/lang/invoke/MethodType.java +++ b/jcl/src/java.base/share/classes/java/lang/invoke/MethodType.java @@ -1,6 +1,6 @@ /*[INCLUDE-IF Sidecar17]*/ /******************************************************************************* - * Copyright (c) 2009, 2018 IBM Corp. and others + * Copyright (c) 2009, 2019 IBM Corp. and others * * This program and the accompanying materials are made available under * the terms of the Eclipse Public License 2.0 which accompanies this @@ -28,6 +28,10 @@ import java.io.ObjectStreamException; import java.io.ObjectStreamField; import java.io.Serializable; +/*[IF Java12]*/ +import java.lang.constant.Constable; +import java.lang.constant.MethodTypeDesc; +/*[ENDIF]*/ import java.lang.ref.Reference; import java.lang.ref.WeakReference; import java.lang.reflect.Field; @@ -38,6 +42,9 @@ import java.util.HashSet; import java.util.List; import java.util.Map; +/*[IF Java12]*/ +import java.util.Optional; +/*[ENDIF]*/ import java.util.Set; import java.util.WeakHashMap; @@ -60,7 +67,11 @@ * @since 1.7 */ @VMCONSTANTPOOL_CLASS -public final class MethodType implements Serializable { +public final class MethodType implements Serializable +/*[IF Java12]*/ + , Constable, TypeDescriptor.OfMethod, MethodType> +/*[ENDIF]*/ +{ static final Class[] EMTPY_PARAMS = new Class[0]; static final Set> WRAPPER_SET; static { @@ -854,7 +865,7 @@ public static MethodType genericMethodType(int numParameters, boolean isVarargs) * * @return the parameter types as an array */ - public Class[] parameterArray(){ + public Class[] parameterArray() { return arguments.clone(); } @@ -863,7 +874,7 @@ public Class[] parameterArray(){ * * @return the number of parameters */ - public int parameterCount(){ + public int parameterCount() { return arguments.length; } @@ -885,7 +896,7 @@ Class[] ptypes() { * * @return the parameter types as a List */ - public List> parameterList(){ + public List> parameterList() { List> list = Arrays.asList(arguments.clone()); return Collections.unmodifiableList(list); } @@ -908,7 +919,7 @@ public Class parameterType(int position) throws IndexOutOfBoundsException { /** * @return the type of the return */ - public Class returnType(){ + public Class returnType() { return returnType; } @@ -1258,5 +1269,17 @@ MethodType asCollectorType(Class clz, int num1) { } /*[ENDIF]*/ /*[ENDIF]*/ + +/*[IF Java12]*/ + public String descriptorString() { + /* Jep334 */ + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } + + public Optional describeConstable() { + /* Jep334 */ + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } +/*[ENDIF]*/ } diff --git a/jcl/src/java.base/share/classes/java/lang/invoke/VarHandle.java b/jcl/src/java.base/share/classes/java/lang/invoke/VarHandle.java index ab77e82e08..b891c7e9e8 100644 --- a/jcl/src/java.base/share/classes/java/lang/invoke/VarHandle.java +++ b/jcl/src/java.base/share/classes/java/lang/invoke/VarHandle.java @@ -28,6 +28,9 @@ import java.util.Arrays; import java.util.Collections; import java.util.List; +/*[IF Java12]*/ +import java.util.Optional; +/*[ENDIF]*/ /*[IF Sidecar19-SE] import jdk.internal.misc.Unsafe; /*[ELSE]*/ @@ -49,7 +52,11 @@ * VarHandle instances are created through the MethodHandles factory API. * */ -public abstract class VarHandle extends VarHandleInternal { +public abstract class VarHandle extends VarHandleInternal +/*[IF Java12]*/ + implements Constable +/*[ENDIF]*/ +{ /** * Access mode identifiers for VarHandle operations. */ @@ -311,6 +318,29 @@ public final Class varType() { public final List> coordinateTypes() { return Collections.unmodifiableList(Arrays.>asList(coordinateTypes)); } + +/*[IF Java12]*/ + public Optional describeConstable() { + /* Jep334 */ + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } + + @Override + public final boolean equals(Object obj) { + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } + + @Override + public final int hashCode() { + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } + + @Override + public final String toString() { + /* Jep334 */ + throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); + } +/*[ENDIF]*/ /** * Each {@link AccessMode}, e.g. get and set, requires different parameters @@ -931,7 +961,7 @@ MethodHandle getFromHandleTable(int operation) { /*[IF Java12]*/ /* nominal descriptor of a VarHandle constant */ - public static final class VarHandleDesc extends DynamicConstantDesc { + public static final class VarHandleDesc extends DynamicConstantDesc implements ConstantDesc { protected VarHandleDesc(DirectMethodHandleDesc bootstrapMethod, String constantName, ClassDesc constantType, ConstantDesc... bootstrapArgs) { super(bootstrapMethod, constantName, constantType, bootstrapArgs); @@ -939,26 +969,34 @@ protected VarHandleDesc(DirectMethodHandleDesc bootstrapMethod, String constantN } public static VarHandleDesc ofArray(ClassDesc arrayClass) { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } public static VarHandleDesc ofField(ClassDesc declaringClass, String name, ClassDesc fieldType) { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } public static VarHandleDesc ofStaticField(ClassDesc declaringClass, String name, ClassDesc fieldType) { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } - public VarHandle resolveConstantDesc(MethodHandles.Lookup lookup) { + @Override + public VarHandle resolveConstantDesc(MethodHandles.Lookup lookup) throws ReflectiveOperationException { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } + @Override public String toString() { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } public ClassDesc varType() { + /* Jep334 */ throw OpenJDKCompileStub.OpenJDKCompileStubThrowError(); } }