changeset 53739:53beb57897f4 jep-334

Specification updates from CSR review
author briangoetz
date Tue, 04 Dec 2018 15:54:33 -0500
parents 46c50472547f
children b3d41cb11883
files src/java.base/share/classes/java/lang/constant/ClassDesc.java src/java.base/share/classes/java/lang/constant/ConstantDescs.java src/java.base/share/classes/java/lang/constant/ConstantUtils.java src/java.base/share/classes/java/lang/constant/DirectMethodHandleDesc.java src/java.base/share/classes/java/lang/constant/DynamicCallSiteDesc.java src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java src/java.base/share/classes/java/lang/constant/MethodHandleDesc.java src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java src/java.base/share/classes/java/lang/constant/package-info.java
diffstat 9 files changed, 93 insertions(+), 53 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.base/share/classes/java/lang/constant/ClassDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/ClassDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -49,9 +49,6 @@
  * {@linkplain ClassDesc} for the component type and then call the {@link #arrayType()}
  * or {@link #arrayType(int)} methods.
  *
- * <p>Two {@linkplain ClassDesc} objects are considered {@link Object#equals(Object)}
- * if they describe exactly the same type.
- *
  * @apiNote In the future, if the Java language permits, {@linkplain ClassDesc}
  * may become a {@code sealed} interface, which would prohibit subclassing except
  * by explicitly permitted types.  Non-platform classes should not implement
@@ -287,4 +284,14 @@
      * @jvms 4.3.2 Field Descriptors
      */
     String descriptorString();
+
+    /**
+     * Compare the specified object with this descriptor for equality.  Returns
+     * {@code true} if and only if the specified object is also a
+     * {@linkplain ClassDesc} and both describe the same type.
+     *
+     * @param o the other object
+     * @return whether this descriptor is equal to the other object
+     */
+    boolean equals(Object o);
 }
--- a/src/java.base/share/classes/java/lang/constant/ConstantDescs.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/ConstantDescs.java	Tue Dec 04 15:54:33 2018 -0500
@@ -156,7 +156,7 @@
     /** {@link ClassDesc} representing {@link MethodHandleDesc} */
     public static final ClassDesc CD_MethodHandleDesc = ClassDesc.of("java.lang.constant.MethodHandleDesc");
 
-    /** {@link ClassDesc} representing {@link DirectMethodHandleDescImpl} */
+    /** {@link ClassDesc} representing {@link DirectMethodHandleDesc} */
     public static final ClassDesc CD_DirectMethodHandleDesc = ClassDesc.of("java.lang.constant.DirectMethodHandleDesc");
 
     /** {@link ClassDesc} representing {@link VarHandleDesc} */
@@ -184,37 +184,37 @@
             ConstantDescs.CD_String,
             ConstantDescs.CD_Class};
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#primitiveClass(Lookup, String, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#primitiveClass(Lookup, String, Class) ConstantBootstraps.primitiveClass} */
     public static final DirectMethodHandleDesc BSM_PRIMITIVE_CLASS
             = ofConstantBootstrap(CD_ConstantBootstraps, "primitiveClass",
             CD_Class);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#enumConstant(Lookup, String, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#enumConstant(Lookup, String, Class) ConstantBootstraps.enumConstant} */
     public static final DirectMethodHandleDesc BSM_ENUM_CONSTANT
             = ofConstantBootstrap(CD_ConstantBootstraps, "enumConstant",
             CD_Enum);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#nullConstant(Lookup, String, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#nullConstant(Lookup, String, Class) ConstantBootstraps.nullConstant} */
     public static final DirectMethodHandleDesc BSM_NULL_CONSTANT
             = ofConstantBootstrap(CD_ConstantBootstraps, "nullConstant",
                                   ConstantDescs.CD_Object);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#fieldVarHandle(Lookup, String, Class, Class, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#fieldVarHandle(Lookup, String, Class, Class, Class) ConstantBootstraps.fieldVarHandle} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_FIELD
             = ofConstantBootstrap(CD_ConstantBootstraps, "fieldVarHandle",
             CD_VarHandle, CD_Class, CD_Class);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#staticFieldVarHandle(Lookup, String, Class, Class, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#staticFieldVarHandle(Lookup, String, Class, Class, Class) ConstantBootstraps.staticVarHandle} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_STATIC_FIELD
             = ofConstantBootstrap(CD_ConstantBootstraps, "staticFieldVarHandle",
             CD_VarHandle, CD_Class, CD_Class);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#arrayVarHandle(Lookup, String, Class, Class)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#arrayVarHandle(Lookup, String, Class, Class) ConstantBootstraps.arrayVarHandle} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_ARRAY
             = ofConstantBootstrap(CD_ConstantBootstraps, "arrayVarHandle",
             CD_VarHandle, CD_Class);
 
-    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#invoke(Lookup, String, Class, MethodHandle, Object...)} */
+    /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#invoke(Lookup, String, Class, MethodHandle, Object...) ConstantBootstraps.invoke} */
     public static final DirectMethodHandleDesc BSM_INVOKE
             = ofConstantBootstrap(CD_ConstantBootstraps, "invoke",
             CD_Object, CD_MethodHandle, CD_Object.arrayType());
@@ -259,7 +259,7 @@
      * an {@code invokedynamic} callsite, which is a static method whose leading
      * parameter types are {@code Lookup}, {@code String}, and {@code MethodType}.
      *
-     * @param clazz the class declaring the method
+     * @param owner the class declaring the method
      * @param name the unqualified name of the method
      * @param returnType the return type of the method
      * @param paramTypes the types of the static bootstrap arguments, if any
@@ -267,11 +267,11 @@
      * @throws NullPointerException if any of the arguments are null
      * @jvms 4.2.2 Unqualified Names
      */
-    public static DirectMethodHandleDesc ofCallsiteBootstrap(ClassDesc clazz,
+    public static DirectMethodHandleDesc ofCallsiteBootstrap(ClassDesc owner,
                                                              String name,
                                                              ClassDesc returnType,
                                                              ClassDesc... paramTypes) {
-        return MethodHandleDesc.ofMethod(STATIC, clazz, name, MethodTypeDesc.of(returnType, paramTypes)
+        return MethodHandleDesc.ofMethod(STATIC, owner, name, MethodTypeDesc.of(returnType, paramTypes)
                                                                             .insertParameterTypes(0, INDY_BOOTSTRAP_ARGS));
     }
 
@@ -280,7 +280,7 @@
      * dynamic constant, which is a static method whose leading arguments are
      * {@code Lookup}, {@code String}, and {@code Class}.
      *
-     * @param clazz the class declaring the method
+     * @param owner the class declaring the method
      * @param name the unqualified name of the method
      * @param returnType the return type of the method
      * @param paramTypes the types of the static bootstrap arguments, if any
@@ -288,11 +288,11 @@
      * @throws NullPointerException if any of the arguments are null
      * @jvms 4.2.2 Unqualified Names
      */
-    public static DirectMethodHandleDesc ofConstantBootstrap(ClassDesc clazz,
+    public static DirectMethodHandleDesc ofConstantBootstrap(ClassDesc owner,
                                                              String name,
                                                              ClassDesc returnType,
                                                              ClassDesc... paramTypes) {
-        return MethodHandleDesc.ofMethod(STATIC, clazz, name, MethodTypeDesc.of(returnType, paramTypes)
+        return MethodHandleDesc.ofMethod(STATIC, owner, name, MethodTypeDesc.of(returnType, paramTypes)
                                                                             .insertParameterTypes(0, CONDY_BOOTSTRAP_ARGS));
     }
 }
--- a/src/java.base/share/classes/java/lang/constant/ConstantUtils.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/ConstantUtils.java	Tue Dec 04 15:54:33 2018 -0500
@@ -70,9 +70,9 @@
         return name;
     }
 
-    static void validateClassOrInterface(ClassDesc clazz) {
-        if (!clazz.isClassOrInterface())
-            throw new IllegalArgumentException("not a class or interface type: " + clazz);
+    static void validateClassOrInterface(ClassDesc classDesc) {
+        if (!classDesc.isClassOrInterface())
+            throw new IllegalArgumentException("not a class or interface type: " + classDesc);
     }
 
     static int arrayDepth(String descriptorString) {
--- a/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -43,7 +43,7 @@
 
 /**
  * A <a href="package-summary.html#nominal">nominal descriptor</a> for a direct
- * {@link MethodHandle}.  A {@linkplain DirectMethodHandleDescImpl} corresponds to
+ * {@link MethodHandle}.  A {@linkplain DirectMethodHandleDesc} corresponds to
  * a {@code Constant_MethodHandle_info} entry in the constant pool of a classfile.
  *
  * @apiNote In the future, if the Java language permits, {@linkplain DirectMethodHandleDesc}
@@ -240,6 +240,7 @@
 
     /**
      * Return 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
      */
--- a/src/java.base/share/classes/java/lang/constant/DynamicCallSiteDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/DynamicCallSiteDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -56,7 +56,7 @@
     /**
      * Create a nominal descriptor for an {@code invokedynamic} call site.
      *
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the {@code invokedynamic}
      * @param invocationName The unqualified name that would appear in the {@code NameAndType}
      *                       operand of the {@code invokedynamic}
@@ -86,7 +86,7 @@
     /**
      * Create a nominal descriptor for an {@code invokedynamic} call site.
      *
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the {@code invokedynamic}
      * @param invocationName The unqualified name that would appear in the {@code NameAndType}
      *                       operand of the {@code invokedynamic}
@@ -132,7 +132,7 @@
      * bootstrap method has no static arguments and for which the name parameter
      * is {@link ConstantDescs#DEFAULT_NAME}.
      *
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the {@code invokedynamic}
      * @param invocationType a {@link MethodTypeDesc} describing the invocation
      *                       type that would appear in the {@code NameAndType}
@@ -204,7 +204,7 @@
     }
 
     /**
-     * Returns a {@link MethodHandleDesc} descripbing the bootstrap method for
+     * Returns a {@link MethodHandleDesc} describing the bootstrap method for
      * the {@code invokedynamic}.
      *
      * @return the bootstrap method for the {@code invokedynamic}
@@ -251,7 +251,7 @@
      *      equals to this {@code DynamicCallSiteDesc}.
      */
     @Override
-    public boolean equals(Object o) {
+    public final boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         DynamicCallSiteDesc specifier = (DynamicCallSiteDesc) o;
@@ -262,12 +262,19 @@
     }
 
     @Override
-    public int hashCode() {
+    public final int hashCode() {
         int result = Objects.hash(bootstrapMethod, invocationName, invocationType);
         result = 31 * result + Arrays.hashCode(bootstrapArgs);
         return result;
     }
 
+    /**
+     * Returns a compact textual description of this call site description,
+     * including the bootstrap method, the invocation name and type, and
+     * the static bootstrap arguments.
+     *
+     * @return A compact textual description of this call site descriptor
+     */
     @Override
     public String toString() {
         return String.format("DynamicCallSiteDesc[%s::%s(%s%s):%s]",
--- a/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -76,11 +76,11 @@
     /**
      * Create a nominal descriptor for a dynamic constant.
      *
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the constant
      * @param constantName The unqualified name that would appear in the {@code NameAndType}
      *                     operand of the {@code LDC} for this constant
-     * @param constantType a {@link DirectMethodHandleDescImpl} describing the type
+     * @param constantType a {@link ClassDesc} describing the type
      *                     that would appear in the {@code NameAndType} operand
      *                     of the {@code LDC} for this constant
      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
@@ -125,7 +125,7 @@
      *                        bootstrap method for the constant
      * @param constantName The unqualified name that would appear in the {@code NameAndType}
      *                     operand of the {@code LDC} for this constant
-     * @param constantType a {@link DirectMethodHandleDescImpl} describing the type
+     * @param constantType a {@link ClassDesc} describing the type
      *                     that would appear in the {@code NameAndType} operand
      *                     of the {@code LDC} for this constant
      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
@@ -149,7 +149,7 @@
      * Return a nominal descriptor for a dynamic constant.
      *
      * @param <T> the type of the dynamic constant
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the constant
      * @param constantName The unqualified name that would appear in the {@code NameAndType}
      *                     operand of the {@code LDC} for this constant
@@ -179,7 +179,7 @@
      * the same as the bootstrap method return type.
      *
      * @param <T> the type of the dynamic constant
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the constant
      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
      *                      to the bootstrap, that would appear in the
@@ -199,7 +199,7 @@
      * and whose type parameter is always the same as the bootstrap method return type.
      *
      * @param <T> the type of the dynamic constant
-     * @param bootstrapMethod a {@link DirectMethodHandleDescImpl} describing the
+     * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
      *                        bootstrap method for the constant
      * @return the nominal descriptor
      * @throws NullPointerException if any argument is null
@@ -372,6 +372,13 @@
         return result;
     }
 
+    /**
+     * Returns a compact textual description of this constant description,
+     * including the bootstrap method, the constant name and type, and
+     * the static bootstrap arguments.
+     *
+     * @return A compact textual description of this call site descriptor
+     */
     @Override
     public String toString() {
         return String.format("DynamicConstantDesc[%s::%s(%s%s)%s]",
--- a/src/java.base/share/classes/java/lang/constant/MethodHandleDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/MethodHandleDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -60,7 +60,7 @@
      * method parameters but not the receiver type.
      *
      * @param kind The kind of method handle to be described
-     * @param clazz a {@link ClassDesc} describing the class containing the
+     * @param owner a {@link ClassDesc} describing the class containing the
      *              method, constructor, or field
      * @param name the unqualified name of the method or field (ignored if
      *             {@code kind} is {@code CONSTRUCTOR})
@@ -76,7 +76,7 @@
      * @jvms 4.3.3 Method Descriptors
      */
     static DirectMethodHandleDesc of(DirectMethodHandleDesc.Kind kind,
-                                     ClassDesc clazz,
+                                     ClassDesc owner,
                                      String name,
                                      String lookupDescriptor) {
         switch (kind) {
@@ -84,9 +84,9 @@
             case SETTER:
             case STATIC_GETTER:
             case STATIC_SETTER:
-                return ofField(kind, clazz, name, ClassDesc.ofDescriptor(lookupDescriptor));
+                return ofField(kind, owner, name, ClassDesc.ofDescriptor(lookupDescriptor));
             default:
-                return new DirectMethodHandleDescImpl(kind, clazz, name, MethodTypeDesc.ofDescriptor(lookupDescriptor));
+                return new DirectMethodHandleDescImpl(kind, owner, name, MethodTypeDesc.ofDescriptor(lookupDescriptor));
         }
     }
 
@@ -104,7 +104,7 @@
      * @param kind The kind of method handle to be described; must be one of
      *             {@code SPECIAL, VIRTUAL, STATIC, INTERFACE_SPECIAL,
      *             INTERFACE_VIRTUAL, INTERFACE_STATIC, CONSTRUCTOR}
-     * @param clazz a {@link ClassDesc} describing the class containing the
+     * @param owner a {@link ClassDesc} describing the class containing the
      *              method or constructor
      * @param name the unqualified name of the method (ignored if {@code kind}
      *             is {@code CONSTRUCTOR})
@@ -116,7 +116,7 @@
      * @jvms 4.2.2 Unqualified Names
      */
     static DirectMethodHandleDesc ofMethod(DirectMethodHandleDesc.Kind kind,
-                                           ClassDesc clazz,
+                                           ClassDesc owner,
                                            String name,
                                            MethodTypeDesc lookupMethodType) {
         switch (kind) {
@@ -132,7 +132,7 @@
             case INTERFACE_STATIC:
             case STATIC:
             case CONSTRUCTOR:
-                return new DirectMethodHandleDescImpl(kind, clazz, name, lookupMethodType);
+                return new DirectMethodHandleDescImpl(kind, owner, name, lookupMethodType);
             default:
                 throw new IllegalArgumentException(kind.toString());
         }
@@ -144,7 +144,7 @@
      *
      * @param kind the kind of the method handle to be described; must be one of {@code GETTER},
      *             {@code SETTER}, {@code STATIC_GETTER}, or {@code STATIC_SETTER}
-     * @param clazz a {@link ClassDesc} describing the class containing the field
+     * @param owner a {@link ClassDesc} describing the class containing the field
      * @param fieldName the unqualified name of the field
      * @param fieldType a {@link ClassDesc} describing the type of the field
      * @return the {@linkplain MethodHandleDesc}
@@ -154,34 +154,34 @@
      * @jvms 4.2.2 Unqualified Names
      */
     static DirectMethodHandleDesc ofField(DirectMethodHandleDesc.Kind kind,
-                                          ClassDesc clazz,
+                                          ClassDesc owner,
                                           String fieldName,
                                           ClassDesc fieldType) {
         MethodTypeDesc mtr;
         switch (kind) {
-            case GETTER: mtr = MethodTypeDesc.of(fieldType, clazz); break;
-            case SETTER: mtr = MethodTypeDesc.of(CD_void, clazz, fieldType); break;
+            case GETTER: mtr = MethodTypeDesc.of(fieldType, owner); break;
+            case SETTER: mtr = MethodTypeDesc.of(CD_void, owner, fieldType); break;
             case STATIC_GETTER: mtr = MethodTypeDesc.of(fieldType); break;
             case STATIC_SETTER: mtr = MethodTypeDesc.of(CD_void, fieldType); break;
             default:
                 throw new IllegalArgumentException(kind.toString());
         }
-        return new DirectMethodHandleDescImpl(kind, clazz, fieldName, mtr);
+        return new DirectMethodHandleDescImpl(kind, owner, fieldName, mtr);
     }
 
     /**
      * Return a {@linkplain MethodHandleDesc} corresponding to invocation of a constructor
      *
-     * @param clazz a {@link ClassDesc} describing the class containing the
+     * @param owner a {@link ClassDesc} describing the class containing the
      *              constructor
      * @param paramTypes {@link ClassDesc}s describing the parameter types of
      *                   the constructor
      * @return the {@linkplain MethodHandleDesc}
      * @throws NullPointerException if any of the arguments are null
      */
-    static DirectMethodHandleDesc ofConstructor(ClassDesc clazz,
+    static DirectMethodHandleDesc ofConstructor(ClassDesc owner,
                                                 ClassDesc... paramTypes) {
-        return MethodHandleDesc.ofMethod(CONSTRUCTOR, clazz, ConstantDescs.DEFAULT_NAME,
+        return MethodHandleDesc.ofMethod(CONSTRUCTOR, owner, ConstantDescs.DEFAULT_NAME,
                                          MethodTypeDesc.of(CD_void, paramTypes));
     }
 
@@ -205,4 +205,15 @@
      * @return a {@linkplain MethodHandleDesc} describing the method handle type
      */
     MethodTypeDesc invocationType();
+
+    /**
+     * Compare the specified object with this descriptor for equality.  Returns
+     * {@code true} if and only if the specified object is also a
+     * {@linkplain MethodHandleDesc}, and both encode the same nominal description
+     * of a method handle.
+     *
+     * @param o the other object
+     * @return whether this descriptor is equal to the other object
+     */
+    boolean equals(Object o);
 }
--- a/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java	Tue Dec 04 15:54:33 2018 -0500
@@ -34,10 +34,6 @@
  * A <a href="package-summary.html#nominal">nominal descriptor</a> for a
  * {@linkplain MethodType} constant.
  *
- * <p>Two {@linkplain MethodTypeDesc} objects are considered {@link Object#equals(Object)}
- * if they have the same arity, their return types are equal, and each pair of corresponding
- * parameter types are equal.
- *
  * @apiNote In the future, if the Java language permits, {@linkplain MethodTypeDesc}
  * may become a {@code sealed} interface, which would prohibit subclassing except
  * by explicitly permitted types.  Non-platform classes should not implement
@@ -191,4 +187,15 @@
                                    .collect(Collectors.joining(",")),
                              returnType().displayName());
     }
+
+    /**
+     * Compare the specified object with this descriptor for equality.  Returns
+     * {@code true} if and only if the specified object is also a
+     * {@linkplain MethodTypeDesc} both have the same arity, their return types
+     * are equal, and each pair of corresponding parameter types are equal.
+     *
+     * @param o the other object
+     * @return whether this descriptor is equal to the other object
+     */
+    boolean equals(Object o);
 }
--- a/src/java.base/share/classes/java/lang/constant/package-info.java	Mon Dec 03 13:56:43 2018 -0500
+++ b/src/java.base/share/classes/java/lang/constant/package-info.java	Tue Dec 04 15:54:33 2018 -0500
@@ -58,7 +58,7 @@
  * of constant values.  For each type of loadable constant pool entry defined in JVMS 4.4,
  * there is a corresponding subtype of {@link java.lang.constant.ConstantDesc}:
  * {@link java.lang.constant.ClassDesc}, {@link java.lang.constant.MethodTypeDesc},
- * {@link java.lang.constant.DirectMethodHandleDescImpl}, {@link java.lang.String},
+ * {@link java.lang.constant.DirectMethodHandleDesc}, {@link java.lang.String},
  * {@link java.lang.Integer}, {@link java.lang.Long}, {@link java.lang.Float},
  * {@link java.lang.Double}, and {@link java.lang.constant.DynamicConstantDesc}.  These classes
  * provides type-specific accessor methods to extract the nominal information for