8356439: Rename JavaLangAccess::*NoRepl methods

src/java.base/share/classes/java/lang/System.java

@@ -2124,6 +2124,7 @@ public Stream<ModuleLayer> layers(ClassLoader loader) {
             public int countPositives(byte[] bytes, int offset, int length) {
                 return StringCoding.countPositives(bytes, offset, length);
             }
+
             public int countNonZeroAscii(String s) {
                 return StringCoding.countNonZeroAscii(s);
             }
@@ -2132,21 +2133,24 @@ public String uncheckedNewStringWithLatin1Bytes(byte[] bytes) {
                 return String.newStringWithLatin1Bytes(bytes);
             }
 
-            public String uncheckedNewStringNoRepl(byte[] bytes, Charset cs) throws CharacterCodingException  {
-                return String.newStringNoRepl(bytes, cs);
+            public String uncheckedNewStringOrThrow(byte[] bytes, Charset cs) throws CharacterCodingException  {
+                return String.newStringOrThrow(bytes, cs);
             }
+
             public char uncheckedGetUTF16Char(byte[] bytes, int index) {
                 return StringUTF16.getChar(bytes, index);
             }
+
             public void uncheckedPutCharUTF16(byte[] bytes, int index, int ch) {
                 StringUTF16.putChar(bytes, index, ch);
             }
-            public byte[] uncheckedGetBytesNoRepl(String s, Charset cs) throws CharacterCodingException {
-                return String.getBytesNoRepl(s, cs);
+
+            public byte[] uncheckedGetBytesOrThrow(String s, Charset cs) throws CharacterCodingException {
+                return String.getBytesOrThrow(s, cs);
             }
 
-            public byte[] getBytesUTF8NoRepl(String s) {
-                return String.getBytesUTF8NoRepl(s);
+            public byte[] getBytesUTF8OrThrow(String s) throws CharacterCodingException {
+                return String.getBytesUTF8OrThrow(s);
             }
 
             public void inflateBytesToChars(byte[] src, int srcOff, char[] dst, int dstOff, int len) {

src/java.base/share/classes/java/nio/file/Files.java

@@ -3043,7 +3043,7 @@ public static String readString(Path path, Charset cs) throws IOException {
         byte[] ba = readAllBytes(path);
         if (path.getClass().getModule() != Object.class.getModule())
             ba = ba.clone();
-        return JLA.uncheckedNewStringNoRepl(ba, cs);
+        return JLA.uncheckedNewStringOrThrow(ba, cs);
     }
 
     /**
@@ -3362,7 +3362,7 @@ public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOpti
         Objects.requireNonNull(csq);
         Objects.requireNonNull(cs);
 
-        byte[] bytes = JLA.uncheckedGetBytesNoRepl(String.valueOf(csq), cs);
+        byte[] bytes = JLA.uncheckedGetBytesOrThrow(String.valueOf(csq), cs);
         if (path.getClass().getModule() != Object.class.getModule())
             bytes = bytes.clone();
         write(path, bytes, options);

src/java.base/share/classes/java/util/zip/ZipCoder.java

@@ -256,15 +256,19 @@ String toString(byte[] ba, int off, int length) {
             try {
                 // Copy subrange for exclusive use by the string being created
                 byte[] bytes = Arrays.copyOfRange(ba, off, off + length);
-                return JLA.uncheckedNewStringNoRepl(bytes, StandardCharsets.UTF_8);
+                return JLA.uncheckedNewStringOrThrow(bytes, StandardCharsets.UTF_8);
             } catch (CharacterCodingException cce) {
                 throw new IllegalArgumentException(cce);
             }
         }
 
         @Override
         byte[] getBytes(String s) {
-            return JLA.getBytesUTF8NoRepl(s);
+            try {
+                return JLA.getBytesUTF8OrThrow(s);
+            } catch (CharacterCodingException cce) {
+                throw new IllegalArgumentException(cce);
+            }
         }
 
         @Override
@@ -278,8 +282,6 @@ int checkedHash(byte[] a, int off, int len) throws Exception {
                 // Non-ASCII, fall back to decoding a String
                 // We avoid using decoder() here since the UTF8ZipCoder is
                 // shared and that decoder is not thread safe.
-                // We use the JLA.newStringUTF8NoRepl variant to throw
-                // exceptions eagerly when opening ZipFiles
                 return hash(toString(a, off, len));
             }
             int h = ArraysSupport.hashCodeOfUnsigned(a, off, len, 0);
@@ -296,7 +298,7 @@ private boolean hasTrailingSlash(byte[] a, int end) {
         @Override
         byte compare(String str, byte[] b, int off, int len, boolean matchDirectory) {
             try {
-                byte[] encoded = JLA.uncheckedGetBytesNoRepl(str, UTF_8.INSTANCE);
+                byte[] encoded = JLA.uncheckedGetBytesOrThrow(str, UTF_8.INSTANCE);
                 int mismatch = Arrays.mismatch(encoded, 0, encoded.length, b, off, off+len);
                 if (mismatch == -1) {
                     return EXACT_MATCH;

src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java

@@ -45,7 +45,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
-import java.util.function.BiFunction;
 import java.util.stream.Stream;
 
 import jdk.internal.loader.NativeLibraries;
@@ -332,7 +331,7 @@ public interface JavaLangAccess {
 
     /**
      * Constructs a new {@code String} by decoding the specified byte array
-     * using the specified {@linkplain java.nio.charset.Charset charset}.
+     * using the specified {@code Charset}.
      * <p>
      * <b>WARNING: The caller of this method shall relinquish and transfer the
      * ownership of the byte array to the callee</b>, since the latter will not
@@ -343,25 +342,22 @@ public interface JavaLangAccess {
      * @return the newly created string
      * @throws CharacterCodingException for malformed or unmappable bytes
      */
-    String uncheckedNewStringNoRepl(byte[] bytes, Charset cs) throws CharacterCodingException;
+    String uncheckedNewStringOrThrow(byte[] bytes, Charset cs) throws CharacterCodingException;
 
     /**
-     * Encode the given string into a sequence of bytes using the specified
-     * {@linkplain java.nio.charset.Charset charset}.
+     * {@return the sequence of bytes obtained by encoding the given string in
+     * the specified {@code Charset}}
      * <p>
      * <b>WARNING: This method returns the {@code byte[]} backing the provided
      * {@code String}, if the input is ASCII. Hence, the returned byte array
      * must not be modified.</b>
-     * <p>
-     * This method throws {@code CharacterCodingException} instead of replacing
-     * when malformed input or unmappable characters are encountered.
      *
      * @param s the string to encode
      * @param cs the charset
-     * @return the encoded bytes
+     * @throws NullPointerException If {@code s} or {@code cs} is null
      * @throws CharacterCodingException for malformed input or unmappable characters
      */
-    byte[] uncheckedGetBytesNoRepl(String s, Charset cs) throws CharacterCodingException;
+    byte[] uncheckedGetBytesOrThrow(String s, Charset cs) throws CharacterCodingException;
 
     /**
      * Get the {@code char} at {@code index} in a {@code byte[]} in internal
@@ -387,13 +383,13 @@ public interface JavaLangAccess {
     void uncheckedPutCharUTF16(byte[] bytes, int index, int ch);
 
     /**
-     * Encode the given string into a sequence of bytes using utf8.
+     * {@return the sequence of bytes obtained by encoding the given string in UTF-8}
      *
      * @param s the string to encode
-     * @return the encoded bytes in utf8
-     * @throws IllegalArgumentException for malformed surrogates
+     * @throws NullPointerException If {@code s} is null
+     * @throws CharacterCodingException For malformed input or unmappable characters
      */
-    byte[] getBytesUTF8NoRepl(String s);
+    byte[] getBytesUTF8OrThrow(String s) throws CharacterCodingException;
 
     /**
      * Inflated copy from {@code byte[]} to {@code char[]}, as defined by

src/java.base/unix/classes/sun/nio/fs/UnixPath.java

@@ -126,7 +126,7 @@ private static String normalize(String input, int len, int off) {
     private static byte[] encode(UnixFileSystem fs, String input) {
         input = fs.normalizeNativePath(input);
         try {
-            return JLA.uncheckedGetBytesNoRepl(input, Util.jnuEncoding());
+            return JLA.uncheckedGetBytesOrThrow(input, Util.jnuEncoding());
         } catch (CharacterCodingException cce) {
             throw new InvalidPathException(input,
                 "Malformed input or input contains unmappable characters");

test/jdk/java/lang/String/NoReplTest.java → test/jdk/java/lang/String/OrThrowTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 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
@@ -24,8 +24,8 @@
 /*
  * @test
  * @bug 8286287 8288589
- * @summary Tests for *NoRepl() shared secret methods.
- * @run testng NoReplTest
+ * @summary Tests for *OrThrow() shared secret methods.
+ * @run testng OrThrowTest
  * @modules jdk.charsets
  */
 
@@ -39,17 +39,17 @@
 import org.testng.annotations.Test;
 
 @Test
-public class NoReplTest {
+public class OrThrowTest {
     private final static byte[] MALFORMED_UTF16 = {(byte)0x00, (byte)0x20, (byte)0x00};
     private final static String MALFORMED_WINDOWS_1252 = "\u0080\u041e";
     private final static Charset WINDOWS_1252 = Charset.forName("windows-1252");
 
     /**
-     * Verifies newStringNoRepl() throws a CharacterCodingException.
-     * The method is invoked by `Files.readString()` method.
+     * Verifies {@code uncheckedNewStringOrThrow()} throws a {@link CharacterCodingException}.
+     * The method is invoked by {@code Files.readString()} method.
      */
     @Test
-    public void newStringNoReplTest() throws IOException {
+    public void uncheckedNewStringOrThrowTest() throws IOException {
         var f = Files.createTempFile(null, null);
         try (var fos = Files.newOutputStream(f)) {
             fos.write(MALFORMED_UTF16);
@@ -67,11 +67,11 @@ public void newStringNoReplTest() throws IOException {
     }
 
     /**
-     * Verifies getBytesNoRepl() throws a CharacterCodingException.
-     * The method is invoked by `Files.writeString()` method.
+     * Verifies {@code uncheckedGetBytesOrThrow()} throws a {@link CharacterCodingException}.
+     * The method is invoked by {@code Files.writeString()} method.
      */
     @Test
-    public void getBytesNoReplTest() throws IOException {
+    public void uncheckedGetBytesOrThrowTest() throws IOException {
         var f = Files.createTempFile(null, null);
         try {
             Files.writeString(f, MALFORMED_WINDOWS_1252, WINDOWS_1252);