fix(java): avoid identifier collisions between distinct wordless names

The wordless-name fallback added in the previous commit collapsed any
input with no legal Java-identifier characters left (e.g. "-", "@") to
the same placeholder ("_"). Two such discriminants as siblings in one
union therefore generated identically-named methods and a duplicate
nested class - generation reported success but emitted non-compiling
Java.

Encode the stripped characters' code points instead of collapsing to a
shared placeholder, so distinct inputs always produce distinct
identifiers (e.g. "-" -> "__2d", "@" -> "__40").

Author: ChoMinGi

generators/java/generator-utils/src/main/java/com/fern/java/utils/CasingConfiguration.java

@@ -195,12 +195,9 @@ private NameParts computeNameInternal(String inputName) {
         // splitWords() only recognizes letter/digit runs, so an input made entirely of
         // separators/symbols (e.g. "_", "-", "@", "-_-") produces zero words and every casing
         // variant above collapses to "". Recover a usable identifier instead of losing the name
-        // entirely: strip characters that aren't legal in a Java identifier and keep whatever's
-        // left (e.g. "$$" stays "$$", "-_-" becomes "_"); if nothing legal remains, fall back to
-        // "_" (which sanitizeName further escapes to "__", since "_" alone is reserved).
+        // entirely.
         if (camelCaseName.isEmpty() && !name.isEmpty()) {
-            String legal = ILLEGAL_IDENTIFIER_CHARS.matcher(name).replaceAll("");
-            String fallback = legal.isEmpty() ? "_" : legal;
+            String fallback = wordlessFallback(name);
             camelCaseName = fallback;
             pascalCaseName = fallback;
             snakeCaseName = fallback;
@@ -223,6 +220,23 @@ private String preprocessName(String name) {
         return name.replace("[]", "Array");
     }
 
+    /**
+     * Fallback identifier for names that produce zero words via splitWords() (e.g. "_", "-", "@", "-_-"). Strips
+     * characters that aren't legal in a Java identifier and keeps whatever's left (e.g. "$$" stays "$$", "-_-" becomes
+     * "_"). If nothing legal remains, encodes each stripped character's code point instead of collapsing to a single
+     * shared placeholder - otherwise distinct inputs like "-" and "@" would both fall back to the same identifier and
+     * silently collide (two identically-named methods/classes) if used as sibling discriminants in the same union.
+     */
+    private static String wordlessFallback(String name) {
+        String legal = ILLEGAL_IDENTIFIER_CHARS.matcher(name).replaceAll("");
+        if (!legal.isEmpty()) {
+            return legal;
+        }
+        StringBuilder encoded = new StringBuilder("_");
+        name.codePoints().forEach(cp -> encoded.append('_').append(Integer.toHexString(cp)));
+        return encoded.toString();
+    }
+
     private String sanitizeName(String name) {
         Set<String> effectiveKeywords = getEffectiveKeywords();
         if (effectiveKeywords == null) {

generators/java/generator-utils/src/test/java/com/fern/java/utils/CasingConfigurationTest.java

@@ -998,19 +998,29 @@ void computeName_ordinaryUnderscoreSeparatedName_unaffected() {
     class WordlessNameTests {
 
         @Test
-        void computeName_dash_fallsBackToUnderscore() {
+        void computeName_dash_encodesCodePoint() {
+            // No legal characters remain, so the code point (0x2d) is encoded instead of
+            // collapsing to a shared placeholder - see computeName_dashAndAt_dontCollide below.
             CasingConfiguration.NameParts parts =
                     buildConfig(true, "java", null).computeName("-");
-            assertThat(parts.camelSafe).isEqualTo("__");
-            assertThat(parts.pascalSafe).isEqualTo("__");
-            assertThat(parts.snakeSafe).isEqualTo("__");
-            assertThat(parts.screamingSnakeSafe).isEqualTo("__");
+            assertThat(parts.camelSafe).isEqualTo("__2d");
+            assertThat(parts.pascalSafe).isEqualTo("__2d");
+            assertThat(parts.snakeSafe).isEqualTo("__2d");
+            assertThat(parts.screamingSnakeSafe).isEqualTo("__2D");
         }
 
         @Test
-        void computeName_at_fallsBackToUnderscore() {
+        void computeName_at_encodesCodePoint() {
             assertThat(buildConfig(true, "java", null).computeName("@").camelSafe)
-                    .isEqualTo("__");
+                    .isEqualTo("__40");
+        }
+
+        @Test
+        void computeName_dashAndAt_dontCollide() {
+            // Distinct wordless inputs must not fall back to the same identifier - that would
+            // silently generate two identically-named methods/classes for sibling discriminants.
+            CasingConfiguration config = buildConfig(true, "java", null);
+            assertThat(config.computeName("-").camelSafe).isNotEqualTo(config.computeName("@").camelSafe);
         }
 
         @Test

generators/java/sdk/changes/unreleased/fix-underscore-discriminator.yml

@@ -6,6 +6,8 @@
     casing logic (used to reconstruct Java identifiers from the IR) collapsed such
     values to an empty string before it could reach the reserved-keyword check, so
     JavaPoet rejected the resulting empty method name. These values now fall back
-    to their legal Java-identifier characters (or `_`, escaped to `__`, if none
-    remain), while the serialized discriminator value is unchanged.
+    to their legal Java-identifier characters, or - if none remain - an encoding of
+    their code points (e.g. `-` becomes `__2d`, `@` becomes `__40`) so that distinct
+    values never collide on the same generated identifier, while the serialized
+    discriminator value is unchanged.
   type: fix