# HG changeset patch
# User jlaskey
# Date 1556030003 10800
#      Tue Apr 23 11:33:23 2019 -0300
# Node ID fdc7e41c23933fc68d09c5002ce257de40ddd3c5
# Parent  b4d37cf7b90e7f6d70e1b9fb806afbe3e359f5aa
8212975: ClassDesc should have a full name method
Reviewed-by: vromero

diff --git a/src/java.base/share/classes/java/lang/constant/ClassDesc.java b/src/java.base/share/classes/java/lang/constant/ClassDesc.java
--- a/src/java.base/share/classes/java/lang/constant/ClassDesc.java
+++ b/src/java.base/share/classes/java/lang/constant/ClassDesc.java
@@ -27,10 +27,9 @@
 import java.lang.invoke.TypeDescriptor;
 import java.util.stream.Stream;
 
-import sun.invoke.util.Wrapper;
-
 import static java.lang.constant.ConstantUtils.binaryToInternal;
 import static java.lang.constant.ConstantUtils.dropLastChar;
+import static java.lang.constant.ConstantUtils.getClassDisplayName;
 import static java.lang.constant.ConstantUtils.internalToBinary;
 import static java.lang.constant.ConstantUtils.validateMemberName;
 import static java.util.Objects.requireNonNull;
@@ -291,21 +290,25 @@
      * @return the human-readable name
      */
     default String displayName() {
-        if (isPrimitive())
-            return Wrapper.forBasicType(descriptorString().charAt(0)).primitiveSimpleName();
-        else if (isClassOrInterface()) {
-            return descriptorString().substring(Math.max(1, descriptorString().lastIndexOf('/') + 1),
-                                                descriptorString().length() - 1);
-        }
-        else if (isArray()) {
-            int depth = ConstantUtils.arrayDepth(descriptorString());
-            ClassDesc c = this;
-            for (int i=0; i<depth; i++)
-                c = c.componentType();
-            return c.displayName() + "[]".repeat(depth);
-        }
-        else
-            throw new IllegalStateException(descriptorString());
+        return getClassDisplayName(this, false);
+    }
+
+    /**
+     * Returns a fully qualified human-readable name for the type described
+     * by this descriptor.
+     *
+     * @implSpec
+     * <p>The default implementation returns the name
+     * (e.g., {@code int}) for primitive types, the qualified class name
+     * for class or interface types (e.g., {@code java.lang.String}),
+     * or the name of the component type with the appropriate
+     * number of {@code []} pairs for array types
+     * (e.g., {@code java.lang.String[]}).
+     *
+     * @return the fully qualified human-readable name
+     */
+    default String displayFullName() {
+        return getClassDisplayName(this, true);
     }
 
     /**
diff --git a/src/java.base/share/classes/java/lang/constant/ConstantUtils.java b/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
--- a/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
+++ b/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
@@ -27,8 +27,12 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Stream;
+
+import sun.invoke.util.Wrapper;
 
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
 
 /**
  * Helper methods for the implementation of {@code java.lang.constant}.
@@ -235,4 +239,39 @@
         }
         return true;
     }
+
+    static String getClassDisplayName(ClassDesc cd, boolean detail) {
+        String descriptor = cd.descriptorString();
+        if (cd.isPrimitive()) {
+           return Wrapper.forBasicType(descriptor
+                         .charAt(0))
+                         .primitiveSimpleName();
+        } else if (cd.isClassOrInterface()) {
+            String internalClassName = ConstantUtils.dropFirstAndLastChar(descriptor);
+            String binaryClassName = internalToBinary(internalClassName);
+            if (detail) {
+                return binaryClassName;
+
+            }
+            int index = binaryClassName.lastIndexOf('.');
+            return index == -1 ? binaryClassName : binaryClassName.substring(index + 1);
+        } else if (cd.isArray()) {
+            int depth = ConstantUtils.arrayDepth(descriptor);
+            ClassDesc c = cd;
+            for (int i=0; i<depth; i++)
+                c = c.componentType();
+            return getClassDisplayName(c, detail) + "[]".repeat(depth);
+        } else {
+            throw new IllegalStateException(descriptor);
+        }
+    }
+
+    static String getDisplayDescriptor(MethodTypeDesc mtd, boolean detail) {
+        return String.format("(%s)%s",
+                Stream.of(mtd.parameterArray())
+                        .map(cd -> getClassDisplayName(cd, detail))
+                        .collect(joining(",")),
+                getClassDisplayName(mtd.returnType(), detail));
+    }
+
 }
diff --git a/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java b/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java
--- a/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java
+++ b/src/java.base/share/classes/java/lang/constant/MethodTypeDesc.java
@@ -30,6 +30,9 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static java.lang.constant.ConstantUtils.getDisplayDescriptor;
+
+
 /**
  * A <a href="package-summary.html#nominal">nominal descriptor</a> for a
  * {@linkplain MethodType} constant.
@@ -181,11 +184,17 @@
      * @return the human-readable descriptor for this method type
      */
     default String displayDescriptor() {
-        return String.format("(%s)%s",
-                             Stream.of(parameterArray())
-                                   .map(ClassDesc::displayName)
-                                   .collect(Collectors.joining(",")),
-                             returnType().displayName());
+        return getDisplayDescriptor(this, false);
+    }
+
+    /**
+     * Returns a human-readable descriptor for this method type, using the
+     * fully qualified canonical names for parameter and return types.
+     *
+     * @return the human-readable descriptor for this method type
+     */
+    default String displayFullDescriptor() {
+        return getDisplayDescriptor(this, true);
     }
 
     /**
diff --git a/test/jdk/java/lang/constant/ClassDescTest.java b/test/jdk/java/lang/constant/ClassDescTest.java
--- a/test/jdk/java/lang/constant/ClassDescTest.java
+++ b/test/jdk/java/lang/constant/ClassDescTest.java
@@ -169,6 +169,13 @@
         assertEquals("", ClassDesc.of("Bar").arrayType().packageName());
     }
 
+    public void testFullDisplayName() {
+        assertEquals(ClassDesc.ofDescriptor("Ljava/lang/String;").displayFullName(), "java.lang.String");
+        assertEquals(ClassDesc.ofDescriptor("[Ljava/lang/String;").displayFullName(), "java.lang.String[]");
+        assertEquals(ClassDesc.ofDescriptor("[[Ljava/lang/String;").displayFullName(), "java.lang.String[][]");
+        assertEquals(ClassDesc.ofDescriptor("I").displayFullName(), "int");
+    }
+
     private void testBadArrayRank(ClassDesc cr) {
         try {
             cr.arrayType(-1);
diff --git a/test/jdk/java/lang/constant/MethodTypeDescTest.java b/test/jdk/java/lang/constant/MethodTypeDescTest.java
--- a/test/jdk/java/lang/constant/MethodTypeDescTest.java
+++ b/test/jdk/java/lang/constant/MethodTypeDescTest.java
@@ -243,4 +243,26 @@
             // good
         }
     }
+
+    private void assertDisplayDescriptor(String ds, Class<?> returnType, Class<?>... argTypes) {
+        MethodType mt = MethodType.methodType(returnType, argTypes);
+        MethodTypeDesc dc =	mt.describeConstable().get();
+        assertEquals(ds, dc.displayDescriptor());
+    }
+
+    private void assertDisplayFullDescriptor(String ds, Class<?> returnType, Class<?>... argTypes) {
+        MethodType mt = MethodType.methodType(returnType, argTypes);
+        MethodTypeDesc dc =	mt.describeConstable().get();
+        assertEquals(ds, dc.displayFullDescriptor());
+    }
+
+    public void testDescriptorDisplay() {
+        assertDisplayDescriptor("(int)int", int.class, int.class);
+        assertDisplayDescriptor("(String)String", String.class, String.class);
+        assertDisplayDescriptor("(String[][])String[]", String[].class, String[][].class);
+
+        assertDisplayFullDescriptor("(int)int", int.class, int.class);
+        assertDisplayFullDescriptor("(java.lang.String)java.lang.String", String.class, String.class);
+        assertDisplayFullDescriptor("(java.lang.String[][])java.lang.String[]", String[].class, String[][].class);
+    }
 }