fix(java): preserve and escape all-underscore discriminator values

CasingConfiguration.computeName() built Java identifiers via toCamelCase(),
which uses a word-splitting regex that never matches underscores. An
all-underscore input like "_" therefore collapsed to an empty string before
the reserved-keyword check ever ran, so JavaPoet rejected the resulting
empty method name for a union discriminant of "_".

Short-circuit all-underscore inputs before word-splitting so they keep
their literal underscores, and add "_" to JAVA_RESERVED_KEYWORDS so it
escapes to "__" like any other reserved identifier, while the serialized
discriminator value stays "_".

Fixes #17431

Author: ChoMinGi

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

@@ -36,12 +36,18 @@ public final class CasingConfiguration {
 
     private static final Pattern STARTS_WITH_NUMBER = Pattern.compile("^[0-9]");
 
+    // splitWords() (and therefore toCamelCase/toBasicSnakeCase/toSmartSnakeCase) never matches
+    // underscores, so an all-underscore input collapses to "" before sanitizeName ever runs.
+    // Short-circuit that case and keep the literal underscores instead of losing them.
+    private static final Pattern ALL_UNDERSCORES = Pattern.compile("^_+$");
+
     // Match lodash words() regex: [A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+
     private static final Pattern SPLIT_WORDS_PATTERN =
             Pattern.compile("[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+");
 
     // Java reserved keywords for keyword sanitization
     private static final Set<String> JAVA_RESERVED_KEYWORDS = Set.of(
+            "_", // reserved since Java 9 (unused lambda param), a compile error since Java 21 (JEP 456)
             "abstract",
             "assert",
             "boolean",
@@ -166,6 +172,11 @@ public NameParts computeName(String inputName) {
     private NameParts computeNameInternal(String inputName) {
         String name = preprocessName(inputName);
 
+        if (ALL_UNDERSCORES.matcher(name).matches()) {
+            String safeName = sanitizeName(name);
+            return new NameParts(inputName, name, safeName, name, safeName, name, safeName, name, safeName);
+        }
+
         String camelCaseName = toCamelCase(name);
         String pascalCaseName = upperFirst(camelCaseName);
         String snakeCaseName;

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

@@ -957,4 +957,38 @@ private static CasingConfiguration buildConfig(boolean smartCasing, String langu
         root.set("casingsConfig", casingsConfig);
         return CasingConfiguration.fromIrJson(root);
     }
+
+    // ===== keyword sanitization: all-underscore inputs =====
+
+    @Nested
+    class UnderscoreTests {
+
+        @Test
+        void computeName_singleUnderscore_isEscaped() {
+            CasingConfiguration config = buildConfig(true, "java", null);
+            CasingConfiguration.NameParts parts = config.computeName("_");
+            assertThat(parts.camelUnsafe).isEqualTo("_");
+            assertThat(parts.camelSafe).isEqualTo("__");
+        }
+
+        @Test
+        void computeName_doubleUnderscore_isAlreadyValid() {
+            CasingConfiguration config = buildConfig(true, "java", null);
+            CasingConfiguration.NameParts parts = config.computeName("__");
+            assertThat(parts.camelUnsafe).isEqualTo("__");
+            assertThat(parts.camelSafe).isEqualTo("__");
+        }
+
+        @Test
+        void computeName_tripleUnderscore_isAlreadyValid() {
+            CasingConfiguration config = buildConfig(true, "java", null);
+            assertThat(config.computeName("___").camelSafe).isEqualTo("___");
+        }
+
+        @Test
+        void computeName_ordinaryUnderscoreSeparatedName_unaffected() {
+            CasingConfiguration config = buildConfig(true, "java", null);
+            assertThat(config.computeName("user_id").camelSafe).isEqualTo("userId");
+        }
+    }
 }

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

@@ -0,0 +1,11 @@
+# yaml-language-server: $schema=../../../../../fern-changes-yml.schema.json
+
+- summary: |
+    Fix generation failure when a discriminated union's discriminator value is a
+    single underscore (`_`). Previously the compressed-name casing logic (used to
+    reconstruct Java identifiers from the IR) collapsed an all-underscore input to
+    an empty string before it could reach the reserved-keyword check, so JavaPoet
+    rejected the resulting empty method name. All-underscore inputs are now kept
+    intact, and `_` is escaped to `__` (matching the existing convention used for
+    other reserved words), while the serialized discriminator value is unchanged.
+  type: fix