pulled string truncation into general util class and added more testing

Author: dougxc

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/common/test/UtilTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.graal.compiler.core.common.test;
+
+import jdk.graal.compiler.core.common.util.Util;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests for {@link jdk.graal.compiler.core.common.util.Util}.
+ */
+public class UtilTest {
+
+    @Test
+    public void truncateStringTest1() {
+        for (int max = 1; max < 1024; max++) {
+
+            String[] inputs = {
+                            "X".repeat(max - 1),
+                            "X".repeat(max),
+                            "X".repeat(max + 1),
+            };
+            for (String s : inputs) {
+                if (max <= Util.TRUNCATION_PLACEHOLDER.length()) {
+                    try {
+                        Util.truncateString(s, max);
+                        throw new AssertionError("expected " + IllegalArgumentException.class.getName());
+                    } catch (IllegalArgumentException e) {
+                        // expected
+                    }
+                } else {
+                    String cs = Util.truncateString(s, max);
+                    if (s.length() <= max) {
+                        Assert.assertEquals(s, cs);
+                    } else {
+                        Assert.assertNotEquals(s, cs);
+                        Assert.assertTrue(cs, cs.contains("<truncated"));
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    public void truncateStringTest2() {
+        int max = 40;
+
+        // Tests example from javadoc
+        String s = "123456789_123456789_123456789_123456789_123456789_";
+        String cs = Util.truncateString(s, max);
+        Assert.assertEquals(50, s.length());
+        Assert.assertEquals(32, cs.length());
+        Assert.assertEquals("123<truncated(43, c285d1fd)>789_", cs);
+    }
+}

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/TruffleInstalledCodeTest.java

@@ -31,25 +31,44 @@
 import jdk.graal.compiler.truffle.TruffleCompilerImpl;
 import jdk.vm.ci.code.InstalledCode;
 
+import java.util.Objects;
+
 public class TruffleInstalledCodeTest extends PartialEvaluationTest {
 
+    /**
+     * Creates a string of length {@code len} whose prefix is repeated 'X's and whose suffix is
+     * {@code suffix}.
+     */
+    private static String makeLongName(int len, String suffix) {
+        return "X".repeat(len - suffix.length()) + suffix;
+    }
+
     /**
      * Tests that {@link TruffleCompilerImpl#asInstalledCodeName(String)} returns a valid name for
      * {@link InstalledCode#InstalledCode(String)}.
      */
     @Test
     public void testLongName() {
-        String prefix = "test__";
-        String middle = new String(new char[Character.MAX_VALUE]).replace('\0', 'X');
         String[] suffixes = {TruffleCompiler.FIRST_TIER_COMPILATION_SUFFIX, TruffleCompiler.SECOND_TIER_COMPILATION_SUFFIX};
         for (String suffix : suffixes) {
-            String name = prefix + middle + suffix;
-            String installedCodeName = TruffleCompilerImpl.asInstalledCodeName(name);
-            Assert.assertTrue(installedCodeName, installedCodeName.length() <= name.length());
-            Assert.assertTrue(installedCodeName, installedCodeName.endsWith(suffix));
+            String[] names = {
+                            makeLongName(TruffleCompilerImpl.MAX_NAME_LENGTH - 1, suffix),
+                            makeLongName(TruffleCompilerImpl.MAX_NAME_LENGTH, suffix),
+                            makeLongName(TruffleCompilerImpl.MAX_NAME_LENGTH + 1, suffix)
+            };
+            for (String name : names) {
+                String installedCodeName = TruffleCompilerImpl.asInstalledCodeName(name);
+                Assert.assertTrue(installedCodeName, installedCodeName.endsWith(suffix));
+                if (name.length() <= TruffleCompilerImpl.MAX_NAME_LENGTH) {
+                    Assert.assertEquals("unexpected truncation", installedCodeName, name);
+                } else {
+                    Assert.assertNotEquals("unexpected truncation", installedCodeName, name);
+                }
 
-            // Must not throw an exception
-            new InstalledCode(installedCodeName);
+                // Must not throw an exception
+                InstalledCode obj = new InstalledCode(installedCodeName);
+                Objects.requireNonNull(obj);
+            }
         }
     }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/util/Util.java

@@ -72,7 +72,7 @@ public static <T> void atPutGrow(List<T> list, int pos, T x, T filler) {
      * possibly non-empty line following the final newline.
      */
     public static String indent(String lines, String indentation) {
-        if (lines.length() == 0) {
+        if (lines.isEmpty()) {
             return lines;
         }
         final String newLine = "\n";
@@ -95,9 +95,7 @@ public static void printInlining(final ResolvedJavaMethod method, final int bci,
         sb.append(String.format("%c%c%c%c%c ", ' ', method.isSynchronized() ? 's' : ' ', ' ', ' ', method.isNative() ? 'n' : ' '));
         sb.append("     ");        // more indent
         sb.append("    ");         // initial inlining indent
-        for (int i = 0; i < inliningDepth; i++) {
-            sb.append("  ");
-        }
+        sb.append("  ".repeat(Math.max(0, inliningDepth)));
         sb.append(String.format("@ %d  %s   %s%s", bci, methodName(method), success ? "" : "not inlining ", String.format(msg, args)));
         TTY.println(sb.toString());
     }
@@ -116,4 +114,48 @@ public static String toString(StackTraceElement[] ste) {
         }
         return sb.toString();
     }
+
+    /**
+     * Transforms {@code s} to be no longer than {code max} via truncation. The truncation replaces
+     * the middle section of {@code s} with {@code "<truncated(" + L + ", " + H + ")>"} where
+     * {@code L} is the length of the cut-out part of {@code s} and H is its hash code in lowercase
+     * hex. Note that if truncation is performed, the returned value may be shorter than
+     * {@code max}. For example:
+     *
+     * <pre>
+     * var s = "123456789_123456789_123456789_123456789_123456789_";
+     * var cs = truncateString(s, 40);
+     * assert s.length() == 50;
+     * assert cs.length() == 32;
+     * assert cs.equals("123<truncated(43, c285d1fd)>789_");
+     * </pre>
+     *
+     * @param max must be greater than the length of {@link #TRUNCATION_PLACEHOLDER}
+     * @throws IllegalArgumentException if {@code max <= TRUNCATION_PLACEHOLDER.length()}
+     */
+    public static String truncateString(String s, int max) {
+        if (max <= TRUNCATION_PLACEHOLDER.length()) {
+            throw new IllegalArgumentException(max + " <= " + TRUNCATION_PLACEHOLDER.length());
+        }
+        if (s.length() > max) {
+            int preservedLen = max - TRUNCATION_PLACEHOLDER.length();
+            int prefixEnd = preservedLen / 2;
+            int suffixStart = (s.length() - preservedLen / 2) - 1;
+            String prefix = s.substring(0, prefixEnd);
+            String middle = s.substring(prefixEnd, suffixStart);
+            middle = TRUNCATION_FORMAT.formatted(middle.length(), middle.hashCode());
+            String suffix = s.substring(suffixStart);
+            return "%s%s%s".formatted(prefix, middle, suffix);
+        }
+        return s;
+    }
+
+    private static final String TRUNCATION_FORMAT = "<truncated(%d, %x)>";
+
+    /**
+     * The placeholder for the value embedded in the value returned by
+     * {@link #truncateString(String, int)} if truncation is performed describing the truncation
+     * performed.
+     */
+    public static final String TRUNCATION_PLACEHOLDER = TRUNCATION_FORMAT.formatted(Integer.MAX_VALUE, String.valueOf(Integer.MAX_VALUE).hashCode());
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleCompilerImpl.java

@@ -42,7 +42,7 @@
 import java.util.concurrent.ThreadFactory;
 import java.util.function.Consumer;
 
-import jdk.graal.compiler.serviceprovider.JavaVersionUtil;
+import jdk.graal.compiler.core.common.util.Util;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.UnmodifiableEconomicMap;
 
@@ -554,7 +554,7 @@ private void compileAST(TruffleCompilationWrapper wrapper, DebugContext debug) {
      * Copy of {@code InstalledCode.MAX_NAME_LENGTH} initialized by reflection that can be removed
      * once JDK 21 support is removed.
      */
-    private static final int MAX_NAME_LENGTH;
+    public static final int MAX_NAME_LENGTH;
     static {
         int len = 2048;
         try {
@@ -567,25 +567,11 @@ private void compileAST(TruffleCompilationWrapper wrapper, DebugContext debug) {
 
     /**
      * Transforms {@code name} to be usable as an {@linkplain InstalledCode#getName() installed code
-     * name}. The value is truncated if too long. The truncation replaces the middle section of the
-     * string with {@code "<truncated(" + L + ", " + H + ")>"} where {@code L} is the length of the
-     * cut-out part of the string and H is its hash code in lowercase hex.
+     * name}. The value is {@linkplain Util#truncateString(String, int) truncated} if its length is
+     * greater than {@link #MAX_NAME_LENGTH}.
      */
     public static String asInstalledCodeName(String name) {
-        String truncationFormat = "<truncated(%d, %x)>";
-        int truncationReserved = (truncationFormat.formatted(Integer.MAX_VALUE, String.valueOf(Integer.MAX_VALUE).hashCode())).length();
-        if (name.length() > MAX_NAME_LENGTH) {
-            int len = MAX_NAME_LENGTH - truncationReserved;
-            int prefixEnd = len / 2;
-            int suffixStart = (name.length() - len / 2) - 1;
-            String prefix = name.substring(0, prefixEnd);
-            String middle = name.substring(prefixEnd, suffixStart);
-            middle = truncationFormat.formatted(middle.length(), middle.hashCode());
-            GraalError.guarantee(truncationReserved >= middle.length(), "%d < %d", truncationReserved, middle.length());
-            String suffix = name.substring(suffixStart);
-            return "%s%s%s".formatted(prefix, middle, suffix);
-        }
-        return name;
+        return Util.truncateString(name, MAX_NAME_LENGTH);
     }
 
     @SuppressWarnings("try")