changeset 52890:db399ba166ac jep-334

renaming CR_* -> CD_* and MHR_* -> MHD_*
author vromero
date Thu, 11 Oct 2018 13:29:09 -0700
parents 9bb1a300931e
children 74ee15ed51dc 8b0bd1ee3674
files src/java.base/share/classes/java/lang/constant/AsTypeMethodHandleDesc.java src/java.base/share/classes/java/lang/constant/ConstantDescs.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/PrimitiveClassDescImpl.java src/java.base/share/classes/java/lang/invoke/VarHandle.java test/jdk/java/lang/constant/ClassDescTest.java test/jdk/java/lang/constant/CondyDescTest.java test/jdk/java/lang/constant/IndyDescTest.java test/jdk/java/lang/constant/MethodHandleDescTest.java test/jdk/java/lang/constant/MethodTypeDescTest.java test/jdk/java/lang/constant/SymbolicDescTest.java test/jdk/java/lang/constant/TypeDescriptorTest.java
diffstat 14 files changed, 198 insertions(+), 198 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.base/share/classes/java/lang/constant/AsTypeMethodHandleDesc.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/AsTypeMethodHandleDesc.java	Thu Oct 11 13:29:09 2018 -0700
@@ -29,7 +29,7 @@
 import java.lang.invoke.MethodType;
 
 import static java.lang.constant.ConstantDescs.BSM_INVOKE;
-import static java.lang.constant.ConstantDescs.CR_MethodHandle;
+import static java.lang.constant.ConstantDescs.CD_MethodHandle;
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -44,8 +44,8 @@
     private final MethodTypeDesc type;
 
     AsTypeMethodHandleDesc(MethodHandleDesc underlying, MethodTypeDesc type) {
-        super(BSM_INVOKE, ConstantDescs.DEFAULT_NAME, CR_MethodHandle,
-              ConstantDescs.MHR_METHODHANDLE_ASTYPE, underlying, type);
+        super(BSM_INVOKE, ConstantDescs.DEFAULT_NAME, CD_MethodHandle,
+              ConstantDescs.MHD_METHODHANDLE_ASTYPE, underlying, type);
         this.underlying = requireNonNull(underlying);
         this.type = requireNonNull(type);
     }
--- a/src/java.base/share/classes/java/lang/constant/ConstantDescs.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/ConstantDescs.java	Thu Oct 11 13:29:09 2018 -0700
@@ -61,223 +61,223 @@
     // Don't change the order of these declarations!
 
     /** {@link ClassDesc} representing {@link Object} */
-    public static final ClassDesc CR_Object = ClassDesc.of("java.lang.Object");
+    public static final ClassDesc CD_Object = ClassDesc.of("java.lang.Object");
 
     /** {@link ClassDesc} representing {@link String} */
-    public static final ClassDesc CR_String = ClassDesc.of("java.lang.String");
+    public static final ClassDesc CD_String = ClassDesc.of("java.lang.String");
 
     /** {@link ClassDesc} representing {@link Class} */
-    public static final ClassDesc CR_Class = ClassDesc.of("java.lang.Class");
+    public static final ClassDesc CD_Class = ClassDesc.of("java.lang.Class");
 
     /** {@link ClassDesc} representing {@link Number} */
-    public static final ClassDesc CR_Number = ClassDesc.of("java.lang.Number");
+    public static final ClassDesc CD_Number = ClassDesc.of("java.lang.Number");
 
     /** {@link ClassDesc} representing {@link Integer} */
-    public static final ClassDesc CR_Integer = ClassDesc.of("java.lang.Integer");
+    public static final ClassDesc CD_Integer = ClassDesc.of("java.lang.Integer");
 
     /** {@link ClassDesc} representing {@link Long} */
-    public static final ClassDesc CR_Long = ClassDesc.of("java.lang.Long");
+    public static final ClassDesc CD_Long = ClassDesc.of("java.lang.Long");
 
     /** {@link ClassDesc} representing {@link Float} */
-    public static final ClassDesc CR_Float = ClassDesc.of("java.lang.Float");
+    public static final ClassDesc CD_Float = ClassDesc.of("java.lang.Float");
 
     /** {@link ClassDesc} representing {@link Double} */
-    public static final ClassDesc CR_Double = ClassDesc.of("java.lang.Double");
+    public static final ClassDesc CD_Double = ClassDesc.of("java.lang.Double");
 
     /** {@link ClassDesc} representing {@link Short} */
-    public static final ClassDesc CR_Short = ClassDesc.of("java.lang.Short");
+    public static final ClassDesc CD_Short = ClassDesc.of("java.lang.Short");
 
     /** {@link ClassDesc} representing {@link Byte} */
-    public static final ClassDesc CR_Byte = ClassDesc.of("java.lang.Byte");
+    public static final ClassDesc CD_Byte = ClassDesc.of("java.lang.Byte");
 
     /** {@link ClassDesc} representing {@link Character} */
-    public static final ClassDesc CR_Character = ClassDesc.of("java.lang.Character");
+    public static final ClassDesc CD_Character = ClassDesc.of("java.lang.Character");
 
     /** {@link ClassDesc} representing {@link Boolean} */
-    public static final ClassDesc CR_Boolean = ClassDesc.of("java.lang.Boolean");
+    public static final ClassDesc CD_Boolean = ClassDesc.of("java.lang.Boolean");
 
     /** {@link ClassDesc} representing {@link Void} */
-    public static final ClassDesc CR_Void = ClassDesc.of("java.lang.Void");
+    public static final ClassDesc CD_Void = ClassDesc.of("java.lang.Void");
 
     /** {@link ClassDesc} representing {@link Throwable} */
-    public static final ClassDesc CR_Throwable = ClassDesc.of("java.lang.Throwable");
+    public static final ClassDesc CD_Throwable = ClassDesc.of("java.lang.Throwable");
 
     /** {@link ClassDesc} representing {@link Exception} */
-    public static final ClassDesc CR_Exception = ClassDesc.of("java.lang.Exception");
+    public static final ClassDesc CD_Exception = ClassDesc.of("java.lang.Exception");
 
     /** {@link ClassDesc} representing {@link Enum} */
-    public static final ClassDesc CR_Enum = ClassDesc.of("java.lang.Enum");
+    public static final ClassDesc CD_Enum = ClassDesc.of("java.lang.Enum");
 
     /** {@link ClassDesc} representing {@link VarHandle} */
-    public static final ClassDesc CR_VarHandle = ClassDesc.of("java.lang.invoke.VarHandle");
+    public static final ClassDesc CD_VarHandle = ClassDesc.of("java.lang.invoke.VarHandle");
 
     /** {@link ClassDesc} representing {@link MethodHandles} */
-    public static final ClassDesc CR_MethodHandles = ClassDesc.of("java.lang.invoke.MethodHandles");
+    public static final ClassDesc CD_MethodHandles = ClassDesc.of("java.lang.invoke.MethodHandles");
 
     /** {@link ClassDesc} representing {@link MethodHandles.Lookup} */
-    public static final ClassDesc CR_MethodHandles_Lookup = CR_MethodHandles.inner("Lookup");
+    public static final ClassDesc CD_MethodHandles_Lookup = CD_MethodHandles.inner("Lookup");
 
     /** {@link ClassDesc} representing {@link MethodHandle} */
-    public static final ClassDesc CR_MethodHandle = ClassDesc.of("java.lang.invoke.MethodHandle");
+    public static final ClassDesc CD_MethodHandle = ClassDesc.of("java.lang.invoke.MethodHandle");
 
     /** {@link ClassDesc} representing {@link MethodType} */
-    public static final ClassDesc CR_MethodType = ClassDesc.of("java.lang.invoke.MethodType");
+    public static final ClassDesc CD_MethodType = ClassDesc.of("java.lang.invoke.MethodType");
 
     /** {@link ClassDesc} representing {@link CallSite} */
-    public static final ClassDesc CR_CallSite = ClassDesc.of("java.lang.invoke.CallSite");
+    public static final ClassDesc CD_CallSite = ClassDesc.of("java.lang.invoke.CallSite");
 
     /** {@link ClassDesc} representing {@link Collection} */
-    public static final ClassDesc CR_Collection = ClassDesc.of("java.util.Collection");
+    public static final ClassDesc CD_Collection = ClassDesc.of("java.util.Collection");
 
     /** {@link ClassDesc} representing {@link List} */
-    public static final ClassDesc CR_List = ClassDesc.of("java.util.List");
+    public static final ClassDesc CD_List = ClassDesc.of("java.util.List");
 
     /** {@link ClassDesc} representing {@link Set} */
-    public static final ClassDesc CR_Set = ClassDesc.of("java.util.Set");
+    public static final ClassDesc CD_Set = ClassDesc.of("java.util.Set");
 
     /** {@link ClassDesc} representing {@link Map} */
-    public static final ClassDesc CR_Map = ClassDesc.of("java.util.Map");
+    public static final ClassDesc CD_Map = ClassDesc.of("java.util.Map");
 
     /** {@link ClassDesc} representing {@link ConstantDesc} */
-    public static final ClassDesc CR_ConstantDesc = ClassDesc.of("java.lang.constant.ConstantDesc");
+    public static final ClassDesc CD_ConstantDesc = ClassDesc.of("java.lang.constant.ConstantDesc");
 
     /** {@link ClassDesc} representing {@link ClassDesc} */
-    public static final ClassDesc CR_ClassDesc = ClassDesc.of("java.lang.constant.ClassDesc");
+    public static final ClassDesc CD_ClassDesc = ClassDesc.of("java.lang.constant.ClassDesc");
 
     /** {@link ClassDesc} representing {@link EnumDesc} */
-    public static final ClassDesc CR_EnumDesc = CR_Enum.inner("EnumDesc");
+    public static final ClassDesc CD_EnumDesc = CD_Enum.inner("EnumDesc");
 
     /** {@link ClassDesc} representing {@link MethodTypeDesc} */
-    public static final ClassDesc CR_MethodTypeDesc = ClassDesc.of("java.lang.constant.MethodTypeDesc");
+    public static final ClassDesc CD_MethodTypeDesc = ClassDesc.of("java.lang.constant.MethodTypeDesc");
 
     /** {@link ClassDesc} representing {@link MethodHandleDesc} */
-    public static final ClassDesc CR_MethodHandleDesc = ClassDesc.of("java.lang.constant.MethodHandleDesc");
+    public static final ClassDesc CD_MethodHandleDesc = ClassDesc.of("java.lang.constant.MethodHandleDesc");
 
     /** {@link ClassDesc} representing {@link DirectMethodHandleDescImpl} */
-    public static final ClassDesc CR_DirectMethodHandleDesc = ClassDesc.of("java.lang.constant.DirectMethodHandleDesc");
+    public static final ClassDesc CD_DirectMethodHandleDesc = ClassDesc.of("java.lang.constant.DirectMethodHandleDesc");
 
     /** {@link ClassDesc} representing {@link VarHandleDesc} */
-    public static final ClassDesc CR_VarHandleDesc = CR_VarHandle.inner("VarHandleDesc");
+    public static final ClassDesc CD_VarHandleDesc = CD_VarHandle.inner("VarHandleDesc");
 
     /** {@link ClassDesc} representing {@link DirectMethodHandleDesc.Kind} */
-    public static final ClassDesc CR_MethodHandleDesc_Kind = CR_DirectMethodHandleDesc.inner("Kind");
+    public static final ClassDesc CD_MethodHandleDesc_Kind = CD_DirectMethodHandleDesc.inner("Kind");
 
     /** {@link ClassDesc} representing {@link DynamicConstantDesc} */
-    public static final ClassDesc CR_DynamicConstantDesc = ClassDesc.of("java.lang.constant.DynamicConstantDesc");
+    public static final ClassDesc CD_DynamicConstantDesc = ClassDesc.of("java.lang.constant.DynamicConstantDesc");
 
     /** {@link ClassDesc} representing {@link DynamicCallSiteDesc} */
-    public static final ClassDesc CR_DynamicCallSiteDesc = ClassDesc.of("java.lang.constant.DynamicCallSiteDesc");
+    public static final ClassDesc CD_DynamicCallSiteDesc = ClassDesc.of("java.lang.constant.DynamicCallSiteDesc");
 
     /** {@link ClassDesc} representing {@link ConstantBootstraps} */
-    public static final ClassDesc CR_ConstantBootstraps = ClassDesc.of("java.lang.invoke.ConstantBootstraps");
+    public static final ClassDesc CD_ConstantBootstraps = ClassDesc.of("java.lang.invoke.ConstantBootstraps");
 
     private static final ClassDesc[] INDY_BOOTSTRAP_ARGS = {
-            ConstantDescs.CR_MethodHandles_Lookup,
-            ConstantDescs.CR_String,
-            ConstantDescs.CR_MethodType };
+            ConstantDescs.CD_MethodHandles_Lookup,
+            ConstantDescs.CD_String,
+            ConstantDescs.CD_MethodType};
 
     private static final ClassDesc[] CONDY_BOOTSTRAP_ARGS = {
-            ConstantDescs.CR_MethodHandles_Lookup,
-            ConstantDescs.CR_String,
-            ConstantDescs.CR_Class };
+            ConstantDescs.CD_MethodHandles_Lookup,
+            ConstantDescs.CD_String,
+            ConstantDescs.CD_Class};
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#primitiveClass(Lookup, String, Class)} */
     public static final DirectMethodHandleDesc BSM_PRIMITIVE_CLASS
-            = ofConstantBootstrap(CR_ConstantBootstraps, "primitiveClass",
-                                  CR_Class);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "primitiveClass",
+            CD_Class);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#enumConstant(Lookup, String, Class)} */
     public static final DirectMethodHandleDesc BSM_ENUM_CONSTANT
-            = ofConstantBootstrap(CR_ConstantBootstraps, "enumConstant",
-                                  CR_Enum);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "enumConstant",
+            CD_Enum);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#nullConstant(Lookup, String, Class)} */
     public static final DirectMethodHandleDesc BSM_NULL_CONSTANT
-            = ofConstantBootstrap(CR_ConstantBootstraps, "nullConstant",
-                                  ConstantDescs.CR_Object);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "nullConstant",
+                                  ConstantDescs.CD_Object);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#fieldVarHandle(Lookup, String, Class, Class, Class)} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_FIELD
-            = ofConstantBootstrap(CR_ConstantBootstraps, "fieldVarHandle",
-                                  CR_VarHandle, CR_Class, CR_Class);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "fieldVarHandle",
+            CD_VarHandle, CD_Class, CD_Class);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#staticFieldVarHandle(Lookup, String, Class, Class, Class)} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_STATIC_FIELD
-            = ofConstantBootstrap(CR_ConstantBootstraps, "staticFieldVarHandle",
-                                  CR_VarHandle, CR_Class, CR_Class);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "staticFieldVarHandle",
+            CD_VarHandle, CD_Class, CD_Class);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#arrayVarHandle(Lookup, String, Class, Class)} */
     public static final DirectMethodHandleDesc BSM_VARHANDLE_ARRAY
-            = ofConstantBootstrap(CR_ConstantBootstraps, "arrayVarHandle",
-                                  CR_VarHandle, CR_Class);
+            = ofConstantBootstrap(CD_ConstantBootstraps, "arrayVarHandle",
+            CD_VarHandle, CD_Class);
 
     /** {@link MethodHandleDesc} representing {@link ConstantBootstraps#invoke(Lookup, String, Class, MethodHandle, Object...)} */
     public static final DirectMethodHandleDesc BSM_INVOKE
-            = ofConstantBootstrap(CR_ConstantBootstraps, "invoke",
-                                  CR_Object, CR_MethodHandle, CR_Object.arrayType());
+            = ofConstantBootstrap(CD_ConstantBootstraps, "invoke",
+            CD_Object, CD_MethodHandle, CD_Object.arrayType());
 
     /** {@link ClassDesc} representing the primitive type {@code int} */
-    public static final ClassDesc CR_int = ClassDesc.ofDescriptor("I");
+    public static final ClassDesc CD_int = ClassDesc.ofDescriptor("I");
 
     /** {@link ClassDesc} representing the primitive type {@code long} */
-    public static final ClassDesc CR_long = ClassDesc.ofDescriptor("J");
+    public static final ClassDesc CD_long = ClassDesc.ofDescriptor("J");
 
     /** {@link ClassDesc} representing the primitive type {@code float} */
-    public static final ClassDesc CR_float = ClassDesc.ofDescriptor("F");
+    public static final ClassDesc CD_float = ClassDesc.ofDescriptor("F");
 
     /** {@link ClassDesc} representing the primitive type {@code double} */
-    public static final ClassDesc CR_double = ClassDesc.ofDescriptor("D");
+    public static final ClassDesc CD_double = ClassDesc.ofDescriptor("D");
 
     /** {@link ClassDesc} representing the primitive type {@code short} */
-    public static final ClassDesc CR_short = ClassDesc.ofDescriptor("S");
+    public static final ClassDesc CD_short = ClassDesc.ofDescriptor("S");
 
     /** {@link ClassDesc} representing the primitive type {@code byte} */
-    public static final ClassDesc CR_byte = ClassDesc.ofDescriptor("B");
+    public static final ClassDesc CD_byte = ClassDesc.ofDescriptor("B");
 
     /** {@link ClassDesc} representing the primitive type {@code char} */
-    public static final ClassDesc CR_char = ClassDesc.ofDescriptor("C");
+    public static final ClassDesc CD_char = ClassDesc.ofDescriptor("C");
 
     /** {@link ClassDesc} representing the primitive type {@code boolean} */
-    public static final ClassDesc CR_boolean = ClassDesc.ofDescriptor("Z");
+    public static final ClassDesc CD_boolean = ClassDesc.ofDescriptor("Z");
 
     /** {@link ClassDesc} representing the primitive type {@code void} */
-    public static final ClassDesc CR_void = ClassDesc.ofDescriptor("V");
+    public static final ClassDesc CD_void = ClassDesc.ofDescriptor("V");
 
     /** Nominal descriptor representing the constant {@code null} */
     public static final ConstantDesc<?> NULL
             = DynamicConstantDesc.ofNamed(ConstantDescs.BSM_NULL_CONSTANT,
-                                          DEFAULT_NAME, ConstantDescs.CR_Object);
+                                          DEFAULT_NAME, ConstantDescs.CD_Object);
 
-    static final DirectMethodHandleDesc MHR_CLASSDESC_FACTORY
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_ClassDesc, "ofDescriptor",
-                                  CR_ClassDesc, CR_String);
+    static final DirectMethodHandleDesc MHD_CLASSDESC_FACTORY
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_ClassDesc, "ofDescriptor",
+            CD_ClassDesc, CD_String);
 
-    static final DirectMethodHandleDesc MHR_METHODHANDLE_ASTYPE
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.VIRTUAL, CR_MethodHandle, "asType",
-                                  CR_MethodHandle, CR_MethodType);
+    static final DirectMethodHandleDesc MHD_METHODHANDLE_ASTYPE
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.VIRTUAL, CD_MethodHandle, "asType",
+            CD_MethodHandle, CD_MethodType);
 
-    static final DirectMethodHandleDesc MHR_DYNAMICCONSTANTDESC_FACTORY
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_DynamicConstantDesc, "of",
-                                  CR_DynamicConstantDesc, CR_DirectMethodHandleDesc, CR_ConstantDesc.arrayType());
+    static final DirectMethodHandleDesc MHD_DYNAMICCONSTANTDESC_FACTORY
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_DynamicConstantDesc, "of",
+            CD_DynamicConstantDesc, CD_DirectMethodHandleDesc, CD_ConstantDesc.arrayType());
 
-    static final DirectMethodHandleDesc MHR_DYNAMICCONSTANTDESC_NAMED_FACTORY
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_DynamicConstantDesc, "ofNamed",
-                                  CR_DynamicConstantDesc, CR_DirectMethodHandleDesc, CR_String, CR_String, CR_ConstantDesc.arrayType());
+    static final DirectMethodHandleDesc MHD_DYNAMICCONSTANTDESC_NAMED_FACTORY
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_DynamicConstantDesc, "ofNamed",
+            CD_DynamicConstantDesc, CD_DirectMethodHandleDesc, CD_String, CD_String, CD_ConstantDesc.arrayType());
 
     /** {@link MethodHandleDesc} representing {@link VarHandleDesc#ofField(ClassDesc, String, ClassDesc)} */
-    public static final DirectMethodHandleDesc MHR_VARHANDLEDESC_OFFIELD
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_VarHandleDesc, "ofField",
-                                  CR_VarHandleDesc, CR_ClassDesc, CR_String, CR_ClassDesc);
+    public static final DirectMethodHandleDesc MHD_VARHANDLEDESC_OFFIELD
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_VarHandleDesc, "ofField",
+            CD_VarHandleDesc, CD_ClassDesc, CD_String, CD_ClassDesc);
 
     /** {@link MethodHandleDesc} representing {@link VarHandleDesc#ofStaticField(ClassDesc, String, ClassDesc)} */
-    public static final DirectMethodHandleDesc MHR_VARHANDLEDESC_OFSTATIC
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_VarHandleDesc, "ofStaticField",
-                                  CR_VarHandleDesc, CR_ClassDesc, CR_String, CR_ClassDesc);
+    public static final DirectMethodHandleDesc MHD_VARHANDLEDESC_OFSTATIC
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_VarHandleDesc, "ofStaticField",
+            CD_VarHandleDesc, CD_ClassDesc, CD_String, CD_ClassDesc);
 
     /** {@link MethodHandleDesc} representing {@link VarHandleDesc#ofArray(ClassDesc)} */
-    public static final DirectMethodHandleDesc MHR_VARHANDLEDESC_OFARRAY
-            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_VarHandleDesc, "ofArray",
-                                  CR_VarHandleDesc, CR_ClassDesc);
+    public static final DirectMethodHandleDesc MHD_VARHANDLEDESC_OFARRAY
+            = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_VarHandleDesc, "ofArray",
+            CD_VarHandleDesc, CD_ClassDesc);
 
     /**
      * Return a {@link MethodHandleDesc} corresponding to a bootstrap method for
--- a/src/java.base/share/classes/java/lang/constant/DynamicCallSiteDesc.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/DynamicCallSiteDesc.java	Thu Oct 11 13:29:09 2018 -0700
@@ -31,7 +31,7 @@
 import java.util.Objects;
 import java.util.stream.Stream;
 
-import static java.lang.constant.ConstantDescs.CR_String;
+import static java.lang.constant.ConstantDescs.CD_String;
 import static java.lang.constant.ConstantUtils.EMPTY_CONSTANTDESC;
 import static java.lang.constant.ConstantUtils.validateMemberName;
 import static java.util.Objects.requireNonNull;
@@ -229,7 +229,7 @@
      * @throws Throwable if any exception is thrown by the bootstrap method
      */
     public CallSite resolveCallSiteDesc(MethodHandles.Lookup lookup) throws Throwable {
-        assert bootstrapMethod.methodType().parameterType(1).equals(CR_String);
+        assert bootstrapMethod.methodType().parameterType(1).equals(CD_String);
         MethodHandle bsm = bootstrapMethod.resolveConstantDesc(lookup);
         Object[] args = new Object[bootstrapArgs.length + 3];
         args[0] = lookup;
--- a/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java	Thu Oct 11 13:29:09 2018 -0700
@@ -36,8 +36,8 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
-import static java.lang.constant.ConstantDescs.CR_Class;
-import static java.lang.constant.ConstantDescs.CR_VarHandle;
+import static java.lang.constant.ConstantDescs.CD_Class;
+import static java.lang.constant.ConstantDescs.CD_VarHandle;
 import static java.lang.constant.ConstantDescs.DEFAULT_NAME;
 import static java.lang.constant.ConstantUtils.EMPTY_CONSTANTDESC;
 import static java.lang.constant.ConstantUtils.validateMemberName;
@@ -315,7 +315,7 @@
 
     private static ConstantDesc<?> canonicalizePrimitiveClass(DynamicConstantDesc<?> desc) {
         if (desc.bootstrapArgs.length != 0
-            || !desc.constantType().equals(CR_Class)
+            || !desc.constantType().equals(CD_Class)
             || desc.constantName == null)
             return desc;
         return ClassDesc.ofDescriptor(desc.constantName);
@@ -323,7 +323,7 @@
 
     private static ConstantDesc<?> canonicalizeStaticFieldVarHandle(DynamicConstantDesc<?> desc) {
         if (desc.bootstrapArgs.length != 3
-            || !desc.constantType().equals(CR_VarHandle))
+            || !desc.constantType().equals(CD_VarHandle))
             return desc;
         return VarHandleDesc.ofStaticField((ClassDesc) desc.bootstrapArgs[0],
                                            (String) desc.bootstrapArgs[1],
@@ -332,7 +332,7 @@
 
     private static ConstantDesc<?> canonicalizeFieldVarHandle(DynamicConstantDesc<?> desc) {
         if (desc.bootstrapArgs.length != 3
-            || !desc.constantType().equals(CR_VarHandle))
+            || !desc.constantType().equals(CD_VarHandle))
             return desc;
         return VarHandleDesc.ofField((ClassDesc) desc.bootstrapArgs[0],
                                      (String) desc.bootstrapArgs[1],
@@ -341,7 +341,7 @@
 
     private static ConstantDesc<?> canonicalizeArrayVarHandle(DynamicConstantDesc<?> desc) {
         if (desc.bootstrapArgs.length != 1
-            || !desc.constantType().equals(CR_VarHandle))
+            || !desc.constantType().equals(CD_VarHandle))
             return desc;
         return VarHandleDesc.ofArray((ClassDesc) desc.bootstrapArgs[0]);
     }
--- a/src/java.base/share/classes/java/lang/constant/MethodHandleDesc.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/MethodHandleDesc.java	Thu Oct 11 13:29:09 2018 -0700
@@ -27,7 +27,7 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 
-import static java.lang.constant.ConstantDescs.CR_void;
+import static java.lang.constant.ConstantDescs.CD_void;
 import static java.lang.constant.DirectMethodHandleDesc.Kind.CONSTRUCTOR;
 
 /**
@@ -163,9 +163,9 @@
         MethodTypeDesc mtr;
         switch (kind) {
             case GETTER: mtr = MethodTypeDesc.of(fieldType, clazz); break;
-            case SETTER: mtr = MethodTypeDesc.of(CR_void, clazz, fieldType); break;
+            case SETTER: mtr = MethodTypeDesc.of(CD_void, clazz, fieldType); break;
             case STATIC_GETTER: mtr = MethodTypeDesc.of(fieldType); break;
-            case STATIC_SETTER: mtr = MethodTypeDesc.of(CR_void, fieldType); break;
+            case STATIC_SETTER: mtr = MethodTypeDesc.of(CD_void, fieldType); break;
             default:
                 throw new IllegalArgumentException(kind.toString());
         }
@@ -185,7 +185,7 @@
     static DirectMethodHandleDesc ofConstructor(ClassDesc clazz,
                                                 ClassDesc... paramTypes) {
         return MethodHandleDesc.of(CONSTRUCTOR, clazz, ConstantDescs.DEFAULT_NAME,
-                                   MethodTypeDesc.of(CR_void, paramTypes));
+                                   MethodTypeDesc.of(CD_void, paramTypes));
     }
 
     /**
--- a/src/java.base/share/classes/java/lang/constant/PrimitiveClassDescImpl.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/constant/PrimitiveClassDescImpl.java	Thu Oct 11 13:29:09 2018 -0700
@@ -50,7 +50,7 @@
      * @jvms 4.3 Descriptors
      */
     PrimitiveClassDescImpl(String descriptor) {
-        super(ConstantDescs.BSM_PRIMITIVE_CLASS, requireNonNull(descriptor), ConstantDescs.CR_Class);
+        super(ConstantDescs.BSM_PRIMITIVE_CLASS, requireNonNull(descriptor), ConstantDescs.CD_Class);
         if (descriptor.length() != 1
             || "VIJCSBFDZ".indexOf(descriptor.charAt(0)) < 0)
             throw new IllegalArgumentException(String.format("not a valid primitive type descriptor: %s", descriptor));
--- a/src/java.base/share/classes/java/lang/invoke/VarHandle.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/src/java.base/share/classes/java/lang/invoke/VarHandle.java	Thu Oct 11 13:29:09 2018 -0700
@@ -2134,9 +2134,9 @@
          * Kinds of variable handle descs
          */
         private enum Kind {
-            FIELD(ConstantDescs.BSM_VARHANDLE_FIELD, ConstantDescs.MHR_VARHANDLEDESC_OFFIELD),
-            STATIC_FIELD(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, ConstantDescs.MHR_VARHANDLEDESC_OFSTATIC),
-            ARRAY(ConstantDescs.BSM_VARHANDLE_ARRAY, ConstantDescs.MHR_VARHANDLEDESC_OFARRAY);
+            FIELD(ConstantDescs.BSM_VARHANDLE_FIELD, ConstantDescs.MHD_VARHANDLEDESC_OFFIELD),
+            STATIC_FIELD(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, ConstantDescs.MHD_VARHANDLEDESC_OFSTATIC),
+            ARRAY(ConstantDescs.BSM_VARHANDLE_ARRAY, ConstantDescs.MHD_VARHANDLEDESC_OFARRAY);
 
             final DirectMethodHandleDesc bootstrapMethod;
             final DirectMethodHandleDesc descFactory;
@@ -2179,7 +2179,7 @@
          */
         private VarHandleDesc(Kind kind, String name, ClassDesc declaringClass, ClassDesc varType) {
             super(kind.bootstrapMethod, name,
-                  ConstantDescs.CR_VarHandle,
+                  ConstantDescs.CD_VarHandle,
                   kind.toBSMArgs(declaringClass, name, varType));
             this.kind = kind;
             this.declaringClass = declaringClass;
--- a/test/jdk/java/lang/constant/ClassDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/ClassDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -172,9 +172,9 @@
         assertEquals("", ClassDesc.of("Bar").packageName());
         assertEquals("", ClassDesc.of("Bar").inner("Baz").packageName());
 
-        testBadPackageName(ConstantDescs.CR_int);
-        testBadPackageName(ConstantDescs.CR_int.arrayType());
-        testBadPackageName(ConstantDescs.CR_String.arrayType());
+        testBadPackageName(ConstantDescs.CD_int);
+        testBadPackageName(ConstantDescs.CD_int.arrayType());
+        testBadPackageName(ConstantDescs.CD_String.arrayType());
         testBadPackageName(ClassDesc.of("Bar").arrayType());
     }
 
@@ -218,8 +218,8 @@
             assertEquals(classToDescriptor(a1.resolveConstantDesc(LOOKUP)), a1.descriptorString());
             assertEquals(classToDescriptor(a2.resolveConstantDesc(LOOKUP)), a2.descriptorString());
 
-            testBadArrayRank(ConstantDescs.CR_int);
-            testBadArrayRank(ConstantDescs.CR_String);
+            testBadArrayRank(ConstantDescs.CD_int);
+            testBadArrayRank(ConstantDescs.CD_String);
             testBadArrayRank(ClassDesc.of("Bar"));
         }
     }
--- a/test/jdk/java/lang/constant/CondyDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/CondyDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -36,11 +36,11 @@
 
 import org.testng.annotations.Test;
 
-import static java.lang.constant.ConstantDescs.CR_MethodHandle;
-import static java.lang.constant.ConstantDescs.CR_Object;
-import static java.lang.constant.ConstantDescs.CR_String;
-import static java.lang.constant.ConstantDescs.CR_VarHandle;
-import static java.lang.constant.ConstantDescs.CR_int;
+import static java.lang.constant.ConstantDescs.CD_MethodHandle;
+import static java.lang.constant.ConstantDescs.CD_Object;
+import static java.lang.constant.ConstantDescs.CD_String;
+import static java.lang.constant.ConstantDescs.CD_VarHandle;
+import static java.lang.constant.ConstantDescs.CD_int;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertNotEquals;
@@ -58,7 +58,7 @@
 @Test
 public class CondyDescTest extends SymbolicDescTest {
     private final static ConstantDesc<?>[] EMPTY_ARGS = new ConstantDesc<?>[0];
-    private final static ClassDesc CR_ConstantBootstraps = ClassDesc.of("java.lang.invoke.ConstantBootstraps");
+    private final static ClassDesc CD_ConstantBootstraps = ClassDesc.of("java.lang.invoke.ConstantBootstraps");
 
     private static<T> void testDCR(DynamicConstantDesc<T> r, T c) throws ReflectiveOperationException {
         assertEquals(r, DynamicConstantDesc.ofNamed(r.bootstrapMethod(), r.constantName(), r.constantType(), r.bootstrapArgs()));
@@ -90,14 +90,14 @@
 
     public void testDynamicConstant() throws ReflectiveOperationException {
         DirectMethodHandleDesc bsmRef = ConstantDescs.ofConstantBootstrap(ClassDesc.of("CondyDescTest"), "concatBSM",
-                                                                            CR_String, CR_String, CR_String);
+                                                                            CD_String, CD_String, CD_String);
         DynamicConstantDesc<String> r = DynamicConstantDesc.of(bsmRef, "foo", "bar");
         testDCR(r, "foobar");
     }
 
     public void testNested() throws Throwable {
-        DirectMethodHandleDesc invoker = ConstantDescs.ofConstantBootstrap(CR_ConstantBootstraps, "invoke", CR_Object, CR_MethodHandle, CR_Object.arrayType());
-        DirectMethodHandleDesc format = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CR_String, "format", CR_String, CR_String, CR_Object.arrayType());
+        DirectMethodHandleDesc invoker = ConstantDescs.ofConstantBootstrap(CD_ConstantBootstraps, "invoke", CD_Object, CD_MethodHandle, CD_Object.arrayType());
+        DirectMethodHandleDesc format = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, CD_String, "format", CD_String, CD_String, CD_Object.arrayType());
 
         String s = (String) invoker.resolveConstantDesc(LOOKUP)
                                    .invoke(LOOKUP, "", String.class,
@@ -131,7 +131,7 @@
         MyClass instance = new MyClass();
 
         // static varHandle
-        VarHandleDesc vhc = VarHandleDesc.ofStaticField(testClass, "sf", CR_int);
+        VarHandleDesc vhc = VarHandleDesc.ofStaticField(testClass, "sf", CD_int);
         VarHandle varHandle = LOOKUP.findStaticVarHandle(MyClass.class, "sf", int.class);
         testVarHandleRef(vhc, varHandle);
 
@@ -141,7 +141,7 @@
         assertEquals(MyClass.sf, 8);
 
         // static varHandle
-        vhc = VarHandleDesc.ofField(testClass, "f", CR_int);
+        vhc = VarHandleDesc.ofField(testClass, "f", CD_int);
         varHandle = LOOKUP.findVarHandle(MyClass.class, "f", int.class);
         testVarHandleRef(vhc, varHandle);
 
@@ -150,7 +150,7 @@
         assertEquals(9, (int) varHandle.get(instance));
         assertEquals(instance.f, 9);
 
-        vhc = VarHandleDesc.ofArray(CR_int.arrayType());
+        vhc = VarHandleDesc.ofArray(CD_int.arrayType());
         varHandle = MethodHandles.arrayElementVarHandle(int[].class);
         testVarHandleRef(vhc, varHandle);
 
@@ -186,16 +186,16 @@
     }
 
     public void testLifting() {
-        DynamicConstantDesc<Object> unliftedNull = DynamicConstantDesc.ofNamed(ConstantDescs.BSM_NULL_CONSTANT, "_", CR_Object, EMPTY_ARGS);
+        DynamicConstantDesc<Object> unliftedNull = DynamicConstantDesc.ofNamed(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_Object, EMPTY_ARGS);
         assertEquals(ConstantDescs.NULL, unliftedNull);
         assertNotSame(ConstantDescs.NULL, unliftedNull);
-        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CR_Object, EMPTY_ARGS));
-        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CR_String, EMPTY_ARGS));
-        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "wahoo", CR_Object, EMPTY_ARGS));
+        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_Object, EMPTY_ARGS));
+        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_String, EMPTY_ARGS));
+        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "wahoo", CD_Object, EMPTY_ARGS));
 
-        assertLifted(CR_int,
-                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CR_Class, EMPTY_ARGS),
-                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CR_Class, EMPTY_ARGS));
+        assertLifted(CD_int,
+                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CD_Class, EMPTY_ARGS),
+                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CD_Class, EMPTY_ARGS));
 
         ClassDesc enumClass = ClassDesc.of("CondyDescTest").inner("MyEnum");
         assertLifted(EnumDesc.of(enumClass, "A"),
@@ -203,15 +203,15 @@
                      DynamicConstantDesc.<MyEnum>ofCanonical(ConstantDescs.BSM_ENUM_CONSTANT, "A", enumClass, EMPTY_ARGS));
 
         ClassDesc testClass = ClassDesc.of("CondyDescTest").inner("MyClass");
-        assertLifted(VarHandleDesc.ofStaticField(testClass, "sf", CR_int),
-                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CR_VarHandle, new ConstantDesc<?>[] {testClass, "sf", CR_int }),
-                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CR_VarHandle, new ConstantDesc<?>[] {testClass, "sf", CR_int }));
-        assertLifted(VarHandleDesc.ofField(testClass, "f", CR_int),
-                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CR_VarHandle, new ConstantDesc<?>[] {testClass, "f", CR_int }),
-                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CR_VarHandle, new ConstantDesc<?>[] {testClass, "f", CR_int }));
-        assertLifted(VarHandleDesc.ofArray(CR_int.arrayType()),
-                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CR_VarHandle, new ConstantDesc<?>[] {CR_int.arrayType() }),
-                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CR_VarHandle, new ConstantDesc<?>[] {CR_int.arrayType() }));
+        assertLifted(VarHandleDesc.ofStaticField(testClass, "sf", CD_int),
+                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CD_VarHandle, new ConstantDesc<?>[] {testClass, "sf", CD_int }),
+                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CD_VarHandle, new ConstantDesc<?>[] {testClass, "sf", CD_int }));
+        assertLifted(VarHandleDesc.ofField(testClass, "f", CD_int),
+                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CD_VarHandle, new ConstantDesc<?>[] {testClass, "f", CD_int }),
+                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CD_VarHandle, new ConstantDesc<?>[] {testClass, "f", CD_int }));
+        assertLifted(VarHandleDesc.ofArray(CD_int.arrayType()),
+                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc<?>[] {CD_int.arrayType() }),
+                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc<?>[] {CD_int.arrayType() }));
     }
 
 }
--- a/test/jdk/java/lang/constant/IndyDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/IndyDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -58,33 +58,33 @@
 
     public void testIndyRef() throws Throwable {
         ClassDesc c = ClassDesc.of("IndyDescTest");
-        MethodTypeDesc mt = MethodTypeDesc.of(CR_CallSite, CR_MethodHandles_Lookup, CR_String, CR_MethodType, CR_Object.arrayType());
+        MethodTypeDesc mt = MethodTypeDesc.of(CD_CallSite, CD_MethodHandles_Lookup, CD_String, CD_MethodType, CD_Object.arrayType());
         DirectMethodHandleDesc mh = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, c, "bootstrap", mt);
-        DynamicCallSiteDesc csd = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CR_String));
+        DynamicCallSiteDesc csd = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CD_String));
         CallSite cs = csd.resolveCallSiteDesc(MethodHandles.lookup());
         MethodHandle target = cs.getTarget();
         assertEquals("Foo", target.invoke());
         assertEquals("wooga", csd.invocationName());
 
-        DynamicCallSiteDesc csd2 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CR_String), "Bar");
+        DynamicCallSiteDesc csd2 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CD_String), "Bar");
         CallSite cs2 = csd2.resolveCallSiteDesc(MethodHandles.lookup());
         MethodHandle target2 = cs2.getTarget();
         assertEquals("Bar", target2.invoke());
         assertEquals("foo", csd2.invocationName());
 
-        DynamicCallSiteDesc csd3 = DynamicCallSiteDesc.of(mh, MethodTypeDesc.of(CR_String));
+        DynamicCallSiteDesc csd3 = DynamicCallSiteDesc.of(mh, MethodTypeDesc.of(CD_String));
         CallSite cs3 = csd.resolveCallSiteDesc(MethodHandles.lookup());
         MethodHandle target3 = cs3.getTarget();
         assertEquals("Foo", target3.invoke());
         assertEquals("_", csd3.invocationName());
 
-        DynamicCallSiteDesc csd4 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CR_String)).withArgs("Bar");
+        DynamicCallSiteDesc csd4 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CD_String)).withArgs("Bar");
         CallSite cs4 = csd4.resolveCallSiteDesc(MethodHandles.lookup());
         MethodHandle target4 = cs4.getTarget();
         assertEquals("Bar", target4.invoke());
 
-        DynamicCallSiteDesc csd5 = DynamicCallSiteDesc.of(mh, MethodTypeDesc.of(CR_String, CR_String))
-                .withNameAndType("foo", MethodTypeDesc.of(CR_String)).withArgs("Bar");
+        DynamicCallSiteDesc csd5 = DynamicCallSiteDesc.of(mh, MethodTypeDesc.of(CD_String, CD_String))
+                .withNameAndType("foo", MethodTypeDesc.of(CD_String)).withArgs("Bar");
         CallSite cs5 = csd5.resolveCallSiteDesc(MethodHandles.lookup());
         MethodHandle target5 = cs5.getTarget();
         assertEquals("Bar", target5.invoke());
@@ -93,12 +93,12 @@
 
     public void testEqualsHashToString() throws Throwable {
         ClassDesc c = ClassDesc.of("IndyDescTest");
-        MethodTypeDesc mt = MethodTypeDesc.of(CR_CallSite, CR_MethodHandles_Lookup, CR_String, CR_MethodType, CR_Object.arrayType());
+        MethodTypeDesc mt = MethodTypeDesc.of(CD_CallSite, CD_MethodHandles_Lookup, CD_String, CD_MethodType, CD_Object.arrayType());
         DirectMethodHandleDesc mh = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, c, "bootstrap", mt);
 
-        DynamicCallSiteDesc csd1 = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CR_String));
-        DynamicCallSiteDesc csd2 = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CR_String));
-        DynamicCallSiteDesc csd3 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CR_String));
+        DynamicCallSiteDesc csd1 = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CD_String));
+        DynamicCallSiteDesc csd2 = DynamicCallSiteDesc.of(mh, "wooga", MethodTypeDesc.of(CD_String));
+        DynamicCallSiteDesc csd3 = DynamicCallSiteDesc.of(mh, "foo", MethodTypeDesc.of(CD_String));
         assertEquals(csd1, csd2);
         assertEquals(csd1.hashCode(), csd2.hashCode());
         assertNotEquals(csd1, csd3);
@@ -110,8 +110,8 @@
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testEmptyInvocationName() throws Throwable {
         ClassDesc c = ClassDesc.of("IndyDescTest");
-        MethodTypeDesc mt = MethodTypeDesc.of(CR_CallSite, CR_MethodHandles_Lookup, CR_String, CR_MethodType, CR_Object.arrayType());
+        MethodTypeDesc mt = MethodTypeDesc.of(CD_CallSite, CD_MethodHandles_Lookup, CD_String, CD_MethodType, CD_Object.arrayType());
         DirectMethodHandleDesc mh = MethodHandleDesc.of(DirectMethodHandleDesc.Kind.STATIC, c, "bootstrap", mt);
-        DynamicCallSiteDesc csd1 = DynamicCallSiteDesc.of(mh, "", MethodTypeDesc.of(CR_String));
+        DynamicCallSiteDesc csd1 = DynamicCallSiteDesc.of(mh, "", MethodTypeDesc.of(CD_String));
     }
 }
--- a/test/jdk/java/lang/constant/MethodHandleDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/MethodHandleDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -47,12 +47,12 @@
 import static java.lang.constant.DirectMethodHandleDesc.Kind.STATIC_GETTER;
 import static java.lang.constant.DirectMethodHandleDesc.Kind.STATIC_SETTER;
 import static java.lang.constant.DirectMethodHandleDesc.Kind.VIRTUAL;
-import static java.lang.constant.ConstantDescs.CR_Integer;
-import static java.lang.constant.ConstantDescs.CR_List;
-import static java.lang.constant.ConstantDescs.CR_Object;
-import static java.lang.constant.ConstantDescs.CR_String;
-import static java.lang.constant.ConstantDescs.CR_int;
-import static java.lang.constant.ConstantDescs.CR_void;
+import static java.lang.constant.ConstantDescs.CD_Integer;
+import static java.lang.constant.ConstantDescs.CD_List;
+import static java.lang.constant.ConstantDescs.CD_Object;
+import static java.lang.constant.ConstantDescs.CD_String;
+import static java.lang.constant.ConstantDescs.CD_int;
+import static java.lang.constant.ConstantDescs.CD_void;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNotSame;
 import static org.testng.Assert.assertTrue;
@@ -109,19 +109,19 @@
     }
 
     public void testSimpleMHs() throws ReflectiveOperationException {
-        testMethodHandleRef(MethodHandleDesc.of(Kind.VIRTUAL, CR_String, "isEmpty", "()Z"),
+        testMethodHandleRef(MethodHandleDesc.of(Kind.VIRTUAL, CD_String, "isEmpty", "()Z"),
                             LOOKUP.findVirtual(String.class, "isEmpty", MethodType.fromMethodDescriptorString("()Z", null)));
-        testMethodHandleRef(MethodHandleDesc.of(Kind.STATIC, CR_String, "format", CR_String, CR_String, CR_Object.arrayType()),
+        testMethodHandleRef(MethodHandleDesc.of(Kind.STATIC, CD_String, "format", CD_String, CD_String, CD_Object.arrayType()),
                             LOOKUP.findStatic(String.class, "format", MethodType.methodType(String.class, String.class, Object[].class)));
-        testMethodHandleRef(MethodHandleDesc.of(Kind.INTERFACE_VIRTUAL, CR_List, "isEmpty", "()Z"),
+        testMethodHandleRef(MethodHandleDesc.of(Kind.INTERFACE_VIRTUAL, CD_List, "isEmpty", "()Z"),
                             LOOKUP.findVirtual(List.class, "isEmpty", MethodType.fromMethodDescriptorString("()Z", null)));
-        testMethodHandleRef(MethodHandleDesc.of(Kind.CONSTRUCTOR, ClassDesc.of("java.util.ArrayList"), "<init>", CR_void),
+        testMethodHandleRef(MethodHandleDesc.of(Kind.CONSTRUCTOR, ClassDesc.of("java.util.ArrayList"), "<init>", CD_void),
                             LOOKUP.findConstructor(ArrayList.class, MethodType.methodType(void.class)));
         testMethodHandleRef(MethodHandleDesc.ofConstructor(ClassDesc.of("java.util.ArrayList")),
                             LOOKUP.findConstructor(ArrayList.class, MethodType.methodType(void.class)));
         // bad constructor non void return type
         try {
-            MethodHandleDesc.of(Kind.CONSTRUCTOR, ClassDesc.of("java.util.ArrayList"), "<init>", CR_int);
+            MethodHandleDesc.of(Kind.CONSTRUCTOR, ClassDesc.of("java.util.ArrayList"), "<init>", CD_int);
             fail("should have failed: non void return type for constructor");
         } catch (IllegalArgumentException ex) {
             // good
@@ -130,8 +130,8 @@
 
     public void testAsType() throws Throwable {
         MethodHandleDesc mhr = MethodHandleDesc.of(Kind.STATIC, ClassDesc.of("java.lang.Integer"), "valueOf",
-                                                   MethodTypeDesc.of(CR_Integer, CR_int));
-        MethodHandleDesc takesInteger = mhr.asType(MethodTypeDesc.of(CR_Integer, CR_Integer));
+                                                   MethodTypeDesc.of(CD_Integer, CD_int));
+        MethodHandleDesc takesInteger = mhr.asType(MethodTypeDesc.of(CD_Integer, CD_Integer));
         testMethodHandleRef(takesInteger);
         MethodHandle mh1 = takesInteger.resolveConstantDesc(LOOKUP);
         assertEquals((Integer) 3, (Integer) mh1.invokeExact((Integer) 3));
@@ -143,7 +143,7 @@
         }
         catch (WrongMethodTypeException ignored) { }
 
-        MethodHandleDesc takesInt = takesInteger.asType(MethodTypeDesc.of(CR_Integer, CR_int));
+        MethodHandleDesc takesInt = takesInteger.asType(MethodTypeDesc.of(CD_Integer, CD_int));
         testMethodHandleRef(takesInt);
         MethodHandle mh2 = takesInt.resolveConstantDesc(LOOKUP);
         assertEquals((Integer) 3, (Integer) mh2.invokeExact(3));
@@ -161,7 +161,7 @@
     }
 
     public void testMethodHandleRef() throws Throwable {
-        MethodHandleDesc ctorRef = MethodHandleDesc.of(Kind.CONSTRUCTOR, testClass, "<ignored!>", CR_void);
+        MethodHandleDesc ctorRef = MethodHandleDesc.of(Kind.CONSTRUCTOR, testClass, "<ignored!>", CD_void);
         MethodHandleDesc staticMethodRef = MethodHandleDesc.of(Kind.STATIC, testClass, "sm", "(I)I");
         MethodHandleDesc staticIMethodRef = MethodHandleDesc.of(Kind.INTERFACE_STATIC, testInterface, "sm", "(I)I");
         MethodHandleDesc instanceMethodRef = MethodHandleDesc.of(Kind.VIRTUAL, testClass, "m", "(I)I");
@@ -218,11 +218,11 @@
         assertEquals(0, (int) privateStaticIMethodRef.resolveConstantDesc(TestHelpers.TestInterface.LOOKUP).invokeExact(5));
         assertEquals(0, (int) privateStaticIMethodRef.resolveConstantDesc(TestHelpers.TestClass.LOOKUP).invokeExact(5));
 
-        MethodHandleDesc staticSetterRef = MethodHandleDesc.ofField(STATIC_SETTER, testClass, "sf", CR_int);
-        MethodHandleDesc staticGetterRef = MethodHandleDesc.ofField(STATIC_GETTER, testClass, "sf", CR_int);
-        MethodHandleDesc staticGetterIRef = MethodHandleDesc.ofField(STATIC_GETTER, testInterface, "sf", CR_int);
-        MethodHandleDesc setterRef = MethodHandleDesc.ofField(SETTER, testClass, "f", CR_int);
-        MethodHandleDesc getterRef = MethodHandleDesc.ofField(GETTER, testClass, "f", CR_int);
+        MethodHandleDesc staticSetterRef = MethodHandleDesc.ofField(STATIC_SETTER, testClass, "sf", CD_int);
+        MethodHandleDesc staticGetterRef = MethodHandleDesc.ofField(STATIC_GETTER, testClass, "sf", CD_int);
+        MethodHandleDesc staticGetterIRef = MethodHandleDesc.ofField(STATIC_GETTER, testInterface, "sf", CD_int);
+        MethodHandleDesc setterRef = MethodHandleDesc.ofField(SETTER, testClass, "f", CD_int);
+        MethodHandleDesc getterRef = MethodHandleDesc.ofField(GETTER, testClass, "f", CD_int);
 
         for (MethodHandleDesc r : List.of(staticSetterRef, staticGetterRef, staticGetterIRef, setterRef, getterRef))
             testMethodHandleRef(r);
--- a/test/jdk/java/lang/constant/MethodTypeDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/MethodTypeDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -33,8 +33,8 @@
 
 import org.testng.annotations.Test;
 
-import static java.lang.constant.ConstantDescs.CR_int;
-import static java.lang.constant.ConstantDescs.CR_void;
+import static java.lang.constant.ConstantDescs.CD_int;
+import static java.lang.constant.ConstantDescs.CD_void;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
 import static org.testng.Assert.assertEquals;
@@ -129,7 +129,7 @@
             testMethodTypeRef(newRef, mt.dropParameterTypes(i, i+1));
         }
 
-        badDropParametersTypes(CR_void, paramDescs);
+        badDropParametersTypes(CD_void, paramDescs);
 
         // addParam
         for (int i=0; i <= paramTypes.length; i++) {
@@ -144,7 +144,7 @@
             }
         }
 
-        badInsertParametersTypes(CR_void, paramDescs);
+        badInsertParametersTypes(CD_void, paramDescs);
     }
 
     private void badInsertParametersTypes(ClassDesc returnType, String... paramDescTypes) {
@@ -238,7 +238,7 @@
         // try with void arguments, this will stress another code path in particular
         // ConstantMethodTypeDesc::init
         try {
-            MethodTypeDesc r = MethodTypeDesc.of(CR_int, CR_void);
+            MethodTypeDesc r = MethodTypeDesc.of(CD_int, CD_void);
             fail("can't reach here");
         }
         catch (IllegalArgumentException e) {
--- a/test/jdk/java/lang/constant/SymbolicDescTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/SymbolicDescTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -55,15 +55,15 @@
     static String[] returnDescs = Stream.concat(Stream.of(paramDescs), Stream.of("V")).toArray(String[]::new);
 
     enum Primitives {
-        INT("I", "int", int.class, int[].class, ConstantDescs.CR_int),
-        LONG("J", "long", long.class, long[].class, ConstantDescs.CR_long),
-        SHORT("S", "short", short.class, short[].class, ConstantDescs.CR_short),
-        BYTE("B", "byte", byte.class, byte[].class, ConstantDescs.CR_byte),
-        CHAR("C", "char", char.class, char[].class, ConstantDescs.CR_char),
-        FLOAT("F", "float", float.class, float[].class, ConstantDescs.CR_float),
-        DOUBLE("D", "double", double.class, double[].class, ConstantDescs.CR_double),
-        BOOLEAN("Z", "boolean", boolean.class, boolean[].class, ConstantDescs.CR_boolean),
-        VOID("V", "void", void.class, null, ConstantDescs.CR_void);
+        INT("I", "int", int.class, int[].class, ConstantDescs.CD_int),
+        LONG("J", "long", long.class, long[].class, ConstantDescs.CD_long),
+        SHORT("S", "short", short.class, short[].class, ConstantDescs.CD_short),
+        BYTE("B", "byte", byte.class, byte[].class, ConstantDescs.CD_byte),
+        CHAR("C", "char", char.class, char[].class, ConstantDescs.CD_char),
+        FLOAT("F", "float", float.class, float[].class, ConstantDescs.CD_float),
+        DOUBLE("D", "double", double.class, double[].class, ConstantDescs.CD_double),
+        BOOLEAN("Z", "boolean", boolean.class, boolean[].class, ConstantDescs.CD_boolean),
+        VOID("V", "void", void.class, null, ConstantDescs.CD_void);
 
         public final String descriptor;
         public final String name;
--- a/test/jdk/java/lang/constant/TypeDescriptorTest.java	Mon Oct 08 20:26:41 2018 +0200
+++ b/test/jdk/java/lang/constant/TypeDescriptorTest.java	Thu Oct 11 13:29:09 2018 -0700
@@ -71,17 +71,17 @@
 
     public void testClassDesc() {
 
-        testArray(CR_int, false, null, CR_int.arrayType());
-        testArray(CR_int.arrayType(), true, CR_int, CR_int.arrayType(2));
-        testArray(CR_int.arrayType(2), true, CR_int.arrayType(), CR_int.arrayType(3));
-        testArray(CR_String, false, null, CR_String.arrayType());
-        testArray(CR_String.arrayType(), true, CR_String, CR_String.arrayType(2));
-        testArray(CR_String.arrayType(2), true, CR_String.arrayType(), CR_String.arrayType(3));
+        testArray(CD_int, false, null, CD_int.arrayType());
+        testArray(CD_int.arrayType(), true, CD_int, CD_int.arrayType(2));
+        testArray(CD_int.arrayType(2), true, CD_int.arrayType(), CD_int.arrayType(3));
+        testArray(CD_String, false, null, CD_String.arrayType());
+        testArray(CD_String.arrayType(), true, CD_String, CD_String.arrayType(2));
+        testArray(CD_String.arrayType(2), true, CD_String.arrayType(), CD_String.arrayType(3));
 
-        assertTrue(CR_int.isPrimitive());
-        assertFalse(CR_int.arrayType().isPrimitive());
-        assertFalse(CR_String.isPrimitive());
-        assertFalse(CR_String.arrayType().isPrimitive());
+        assertTrue(CD_int.isPrimitive());
+        assertFalse(CD_int.arrayType().isPrimitive());
+        assertFalse(CD_String.isPrimitive());
+        assertFalse(CD_String.arrayType().isPrimitive());
     }
 
 }