8338544: Dedicated Array class descriptor implementation

Reviewed-by: redestad, mchung, jvernee

Author: liach

src/java.base/share/classes/java/lang/constant/ClassDesc.java

@@ -26,22 +26,13 @@
 
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.TypeDescriptor;
-import java.util.stream.Stream;
 
+import jdk.internal.constant.ArrayClassDescImpl;
+import jdk.internal.constant.ConstantUtils;
 import jdk.internal.constant.PrimitiveClassDescImpl;
-import jdk.internal.constant.ReferenceClassDescImpl;
-import sun.invoke.util.Wrapper;
+import jdk.internal.constant.ClassOrInterfaceDescImpl;
 
-import static java.util.stream.Collectors.joining;
-import static jdk.internal.constant.ConstantUtils.MAX_ARRAY_TYPE_DESC_DIMENSIONS;
-import static jdk.internal.constant.ConstantUtils.arrayDepth;
-import static jdk.internal.constant.ConstantUtils.binaryToInternal;
-import static jdk.internal.constant.ConstantUtils.concat;
-import static jdk.internal.constant.ConstantUtils.forPrimitiveType;
-import static jdk.internal.constant.ConstantUtils.internalToBinary;
-import static jdk.internal.constant.ConstantUtils.validateBinaryClassName;
-import static jdk.internal.constant.ConstantUtils.validateInternalClassName;
-import static jdk.internal.constant.ConstantUtils.validateMemberName;
+import static jdk.internal.constant.ConstantUtils.*;
 
 /**
  * A <a href="package-summary.html#nominal">nominal descriptor</a> for a
@@ -64,7 +55,8 @@ public sealed interface ClassDesc
         extends ConstantDesc,
                 TypeDescriptor.OfField<ClassDesc>
         permits PrimitiveClassDescImpl,
-                ReferenceClassDescImpl {
+                ClassOrInterfaceDescImpl,
+                ArrayClassDescImpl {
 
     /**
      * Returns a {@linkplain ClassDesc} for a class or interface type,
@@ -84,7 +76,7 @@ public sealed interface ClassDesc
      */
     static ClassDesc of(String name) {
         validateBinaryClassName(name);
-        return ClassDesc.ofDescriptor(concat("L", binaryToInternal(name), ";"));
+        return ConstantUtils.binaryNameToDesc(name);
     }
 
     /**
@@ -110,7 +102,7 @@ static ClassDesc of(String name) {
      */
     static ClassDesc ofInternalName(String name) {
         validateInternalClassName(name);
-        return ClassDesc.ofDescriptor(concat("L", name, ";"));
+        return ConstantUtils.internalNameToDesc(name);
     }
 
     /**
@@ -129,11 +121,11 @@ static ClassDesc ofInternalName(String name) {
      */
     static ClassDesc of(String packageName, String className) {
         validateBinaryClassName(packageName);
+        validateMemberName(className, false);
         if (packageName.isEmpty()) {
-            return of(className);
+            return internalNameToDesc(className);
         }
-        validateMemberName(className, false);
-        return ofDescriptor('L' + binaryToInternal(packageName) +
+        return ClassOrInterfaceDescImpl.ofValidated('L' + binaryToInternal(packageName) +
                 '/' + className + ';');
     }
 
@@ -168,7 +160,7 @@ static ClassDesc ofDescriptor(String descriptor) {
         return (descriptor.length() == 1)
                ? forPrimitiveType(descriptor, 0)
                // will throw IAE on descriptor.length == 0 or if array dimensions too long
-               : ReferenceClassDescImpl.of(descriptor);
+               : parseReferenceTypeDesc(descriptor);
     }
 
     /**
@@ -180,20 +172,7 @@ static ClassDesc ofDescriptor(String descriptor) {
      * ClassDesc} would have an array rank of greater than 255
      * @jvms 4.4.1 The CONSTANT_Class_info Structure
      */
-    default ClassDesc arrayType() {
-        String desc = descriptorString();
-        int depth = arrayDepth(desc);
-        if (depth >= MAX_ARRAY_TYPE_DESC_DIMENSIONS) {
-            throw new IllegalStateException(
-                    "Cannot create an array type descriptor with more than " +
-                    MAX_ARRAY_TYPE_DESC_DIMENSIONS + " dimensions");
-        }
-        String newDesc = "[".concat(desc);
-        if (desc.length() == 1 && desc.charAt(0) == 'V') {
-            throw new IllegalArgumentException("not a valid reference type descriptor: " + newDesc);
-        }
-        return ReferenceClassDescImpl.ofValidated(newDesc);
-    }
+    ClassDesc arrayType();
 
     /**
      * Returns a {@linkplain ClassDesc} for an array type of the specified rank,
@@ -206,24 +185,7 @@ default ClassDesc arrayType() {
      * greater than 255
      * @jvms 4.4.1 The CONSTANT_Class_info Structure
      */
-    default ClassDesc arrayType(int rank) {
-        if (rank <= 0) {
-            throw new IllegalArgumentException("rank " + rank + " is not a positive value");
-        }
-        String desc = descriptorString();
-        long currentDepth = arrayDepth(desc);
-        long netRank = currentDepth + rank;
-        if (netRank > MAX_ARRAY_TYPE_DESC_DIMENSIONS) {
-            throw new IllegalArgumentException("rank: " + netRank +
-                    " exceeds maximum supported dimension of " +
-                    MAX_ARRAY_TYPE_DESC_DIMENSIONS);
-        }
-        String newDesc = new StringBuilder(desc.length() + rank).repeat('[', rank).append(desc).toString();
-        if (desc.length() == 1 && desc.charAt(0) == 'V') {
-            throw new IllegalArgumentException("not a valid reference type descriptor: " + newDesc);
-        }
-        return ReferenceClassDescImpl.ofValidated(newDesc);
-    }
+    ClassDesc arrayType(int rank);
 
     /**
      * Returns a {@linkplain ClassDesc} for a nested class of the class or
@@ -243,13 +205,7 @@ default ClassDesc arrayType(int rank) {
      * @throws IllegalArgumentException if the nested class name is invalid
      */
     default ClassDesc nested(String nestedName) {
-        validateMemberName(nestedName, false);
-        if (!isClassOrInterface())
-            throw new IllegalStateException("Outer class is not a class or interface type");
-        String desc = descriptorString();
-        StringBuilder sb = new StringBuilder(desc.length() + nestedName.length() + 1);
-        sb.append(desc, 0, desc.length() - 1).append('$').append(nestedName).append(';');
-        return ReferenceClassDescImpl.ofValidated(sb.toString());
+        throw new IllegalStateException("Outer class is not a class or interface type");
     }
 
     /**
@@ -266,16 +222,7 @@ default ClassDesc nested(String nestedName) {
      * @throws IllegalArgumentException if the nested class name is invalid
      */
     default ClassDesc nested(String firstNestedName, String... moreNestedNames) {
-        if (!isClassOrInterface())
-            throw new IllegalStateException("Outer class is not a class or interface type");
-        validateMemberName(firstNestedName, false);
-        // implicit null-check
-        for (String addNestedNames : moreNestedNames) {
-            validateMemberName(addNestedNames, false);
-        }
-        return moreNestedNames.length == 0
-               ? nested(firstNestedName)
-               : nested(firstNestedName + Stream.of(moreNestedNames).collect(joining("$", "$", "")));
+        throw new IllegalStateException("Outer class is not a class or interface type");
     }
 
     /**
@@ -284,7 +231,7 @@ default ClassDesc nested(String firstNestedName, String... moreNestedNames) {
      * @return whether this {@linkplain ClassDesc} describes an array type
      */
     default boolean isArray() {
-        return descriptorString().charAt(0) == '[';
+        return false;
     }
 
     /**
@@ -293,7 +240,7 @@ default boolean isArray() {
      * @return whether this {@linkplain ClassDesc} describes a primitive type
      */
     default boolean isPrimitive() {
-        return descriptorString().length() == 1;
+        return false;
     }
 
     /**
@@ -302,7 +249,7 @@ default boolean isPrimitive() {
      * @return whether this {@linkplain ClassDesc} describes a class or interface type
      */
     default boolean isClassOrInterface() {
-        return descriptorString().charAt(0) == 'L';
+        return false;
     }
 
     /**
@@ -313,14 +260,6 @@ default boolean isClassOrInterface() {
      * if this descriptor does not describe an array type
      */
     default ClassDesc componentType() {
-        if (isArray()) {
-            String desc = descriptorString();
-            if (desc.length() == 2) {
-                return Wrapper.forBasicType(desc.charAt(1)).basicClassDescriptor();
-            } else {
-                return ReferenceClassDescImpl.ofValidated(desc.substring(1));
-            }
-        }
         return null;
     }
 
@@ -332,41 +271,17 @@ default ClassDesc componentType() {
      * default package, or this {@linkplain ClassDesc} does not describe a class or interface type
      */
     default String packageName() {
-        if (!isClassOrInterface())
-            return "";
-        String desc = descriptorString();
-        int index = desc.lastIndexOf('/');
-        return (index == -1) ? "" : internalToBinary(desc.substring(1, index));
+        return "";
     }
 
     /**
-     * Returns a human-readable name for the type described by this descriptor.
-     *
-     * @implSpec
-     * <p>The default implementation returns the simple name
-     * (e.g., {@code int}) for primitive types, the unqualified class name
-     * for class or interface types, or the display name of the component type
-     * suffixed with the appropriate number of {@code []} pairs for array types.
-     *
-     * @return the human-readable name
+     * {@return a human-readable name for this {@code ClassDesc}}
+     * For primitive types, this method returns the simple name (such as {@code int}).
+     * For class or interface types, this method returns the unqualified class name.
+     * For array types, this method returns the human-readable name of the component
+     * type suffixed with the appropriate number of {@code []} pairs.
      */
-    default String displayName() {
-        if (isPrimitive())
-            return Wrapper.forBasicType(descriptorString().charAt(0)).primitiveSimpleName();
-        else if (isClassOrInterface()) {
-            String desc = descriptorString();
-            return desc.substring(Math.max(1, desc.lastIndexOf('/') + 1), desc.length() - 1);
-        }
-        else if (isArray()) {
-            int depth = arrayDepth(descriptorString());
-            ClassDesc c = this;
-            for (int i=0; i<depth; i++)
-                c = c.componentType();
-            return c.displayName().concat("[]".repeat(depth));
-        }
-        else
-            throw new IllegalStateException(descriptorString());
-    }
+    String displayName();
 
     /**
      * Returns a field type descriptor string for this type