fix(scala): decline, rather than fail, types with unresolvable members

Addresses the fifth AI review round, where both reviewers independently found
the same gap.

Guarding only `Class.forName` was not enough to keep recognition free of linkage
failures. `getField` and `getMethods` resolve member descriptors, so a companion
or case class declaring a member whose type is absent at runtime threw a
`NoClassDefFoundError` out of `isCaseClass` for a type this module does not own.
Recognition now declines such a type; the owning path still reports it. Ambiguity
stays loud, and the comment says so rather than promising blanket quiet.

`CompanionOwner` keeps one piece of state: static forwarders are exactly the
absence of a companion singleton.

The literal-name comment named the wrong mechanism again. Verified against the
compiled classes: a one-level companion is enclosed by the mirror class, so its
canonical name ends with its only `$` and resolves; two or more levels put a
`$`-terminated segment in the middle, which the generated-code compiler cannot
resolve through.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: pjfanning

docs/json/scala.md

@@ -51,9 +51,9 @@ constructor arguments exactly as Scala defines them. A missing parameter without
 error. Mutable body properties are applied after construction.
 
 A case class may be declared at the top level, or inside an `object` at any nesting depth, as long
-as every enclosing scope is itself an `object`. A case class enclosed by a `class`, a trait, or a method
-is rejected for both reading and writing, because Fory cannot reach the enclosing instance or the
-companion it needs to rebuild the value.
+as every enclosing scope is itself an `object`. A case class enclosed by a `class`, a trait, or a
+method is rejected for both reading and writing, because Fory cannot reach the enclosing instance
+or the companion it needs to rebuild the value.
 
 Fory JSON annotations can be placed directly on Scala constructor properties:
 

java/fory-core/src/main/java/org/apache/fory/reflect/ReflectionUtils.java

@@ -633,11 +633,11 @@ public static String getLiteralName(Class<?> cls) {
       if (canonicalName.contains("$")) {
         // nested scala object type can't be accessed in java by using canonicalName. This includes
         // a nested module class, whose own name ends with `$`: the canonical name of a companion
-        // declared two or more levels inside an object mixes `.` and `$` separators, which the
-        // generated-code compiler mangles back into a name that resolves to nothing
-        // ("pkg.A$B$ declares no member type C$"). A module class only one level deep keeps its
-        // canonical name, because only its last segment ends with `$`, so the nesting-level bound
-        // below is load bearing in both directions.
+        // declared two or more levels inside an object has a `$`-terminated segment in the
+        // middle of its canonical name, one per enclosing module class, and the generated-code
+        // compiler cannot resolve through those ("pkg.A$B$ declares no member type C$"). One level
+        // deep is enclosed by the mirror class instead, so `pkg.A.C$` ends with the only `$` and
+        // still resolves: the nesting-level bound below is load bearing in both directions.
         // see more detailed in
         // https://stackoverflow.com/questions/30809070/accessing-scala-nested-classes-from-java
         int nestedLevels = 0;

java/fory-json/src/main/java17/org/apache/fory/json/ForyJsonGraalVMFeature.java

@@ -117,7 +117,7 @@ final class ForyJsonGraalVMFeature implements Feature {
   // Reflection-only registrations are tracked apart from processedCreators, whose membership also
   // means a creator handle was retained.
   private final Set<Method> processedReflectiveMethods = new LinkedHashSet<>();
-  private final Set<Class<?>> scalaCompanionsConsidered = new LinkedHashSet<>();
+  private final Set<Class<?>> typesConsideredForScalaCompanion = new LinkedHashSet<>();
   private final Set<ObjectCodec<?>> processedObjectModels =
       Collections.newSetFromMap(new IdentityHashMap<>());
   private final ArrayList<HostedConfiguration> hostedConfigurations = new ArrayList<>();
@@ -880,7 +880,7 @@ private void registerRecord(Class<?> type) {
    * reflectively while rebuilding the object model at image runtime.
    */
   private void registerScalaCompanion(Class<?> type) {
-    if (!scalaCompanionsConsidered.add(type) || hasScalaStaticFactory(type)) {
+    if (!typesConsideredForScalaCompanion.add(type) || hasScalaStaticFactory(type)) {
       return;
     }
     Class<?> companion;

scala/fory-json-scala/src/main/scala/org/apache/fory/json/scala/internal/ScalaObjectModels.scala

@@ -32,16 +32,26 @@ private[scala] object ScalaObjectModels {
     if (!classOf[Product].isAssignableFrom(typeClass) || name.startsWith("scala.Tuple")) {
       return false
     }
-    val companion = companionOwner(typeClass, committed = false)
-    if (companion != null) return findPrimaryConstructor(typeClass, companion) != null
-    // A case class that cannot reach its companion, such as one declared inside a class or a
-    // method, is still a case class. Claim it so the codec reports the exact reason instead of
-    // leaving it to a generic object model that silently drops every property. A generated `copy`
-    // returning the declaring class together with a declared `productPrefix`, which `Product`
-    // otherwise supplies by default, is the compiler marker of a case class. Standard-library
-    // types keep their own mapping. A reachable companion whose constructor this module does not
-    // support, such as a varargs or non-public primary constructor, keeps its previous handling.
-    !name.startsWith("scala.") && declaresCopy(typeClass) && declaresProductPrefix(typeClass)
+    // Recognition answers a predicate for every Product reaching this module, including types it
+    // does not own, and reflecting over a companion or a case class resolves member descriptors.
+    // A type whose members reference absent classes must simply be declined here; the owning path
+    // reports the failure. Ambiguity stays loud: it means this module does own the type and cannot
+    // pick a constructor.
+    try {
+      val companion = companionOwner(typeClass, committed = false)
+      if (companion != null) findPrimaryConstructor(typeClass, companion) != null
+      else {
+        // A case class that cannot reach its companion, such as one declared inside a class or a
+        // method, is still a case class. Claim it so the codec reports the exact reason instead of
+        // leaving it to a generic object model that silently drops every property. A generated
+        // `copy` returning the declaring class together with a declared `productPrefix`, which
+        // `Product` otherwise supplies by default, is the compiler marker of a case class.
+        // Standard-library types keep their own mapping. A reachable companion whose constructor
+        // this module does not support, such as a varargs or non-public primary constructor, keeps
+        // its previous handling.
+        !name.startsWith("scala.") && declaresCopy(typeClass) && declaresProductPrefix(typeClass)
+      }
+    } catch { case _: LinkageError => false }
   }
 
   def caseClassCodec(typeRef: TypeRef[_], resolver: JsonTypeResolver): ObjectCodec[_] = {
@@ -227,11 +237,9 @@ private[scala] object ScalaObjectModels {
    * only for a top-level companion, so a case class declared inside an `object` keeps them as
    * instance members of the companion singleton.
    */
-  private final class CompanionOwner(
-      val owner: Class[_],
-      val singleton: Field,
-      val staticForwarders: Boolean
-  )
+  private final class CompanionOwner(val owner: Class[_], val singleton: Field) {
+    def staticForwarders: Boolean = singleton == null
+  }
 
   // `fory-json` mirrors this companion rule in two places that must stay in sync: the
   // `ownerType + "$"` check in JsonCreatorInfo.buildDefaultInvokers, and the native-image
@@ -250,7 +258,7 @@ private[scala] object ScalaObjectModels {
       if (
         method.getName == "apply" && Modifier.isStatic(method.getModifiers) &&
         !method.isBridge && !method.isSynthetic && method.getReturnType == typeClass
-      ) return new CompanionOwner(typeClass, null, true)
+      ) return new CompanionOwner(typeClass, null)
       index += 1
     }
     val companionName = typeClass.getName + "$"
@@ -267,7 +275,7 @@ private[scala] object ScalaObjectModels {
       }
     val field = singletonField(companionClass)
     if (!Modifier.isPublic(companionClass.getModifiers) || field == null) null
-    else new CompanionOwner(companionClass, field, false)
+    else new CompanionOwner(companionClass, field)
   }
 
   private def companionInstance(typeRef: TypeRef[_], companion: CompanionOwner): AnyRef = {