wenshao commented on code in PR #3907:
URL: https://github.com/apache/fory/pull/3907#discussion_r3696546519


##########
java/fory-json/src/main/java/org/apache/fory/json/codec/SqlJsonCodecs.java:
##########
@@ -110,12 +122,16 @@ public T readUtf8(Utf8JsonReader reader) {
       return reader.tryReadNullToken() ? null : newSqlValue(reader.readLong());
     }
 
+    @SuppressWarnings("unchecked")
     private T newSqlValue(long millis) {
       try {
-        return constructor.newInstance(millis);
+        return constructorHandle == null
+            ? constructor.newInstance(millis)
+            : (T) constructorHandle.invoke(millis);
       } catch (ReflectiveOperationException e) {
-        throw new ForyJsonException(
-            "Cannot create SQL JSON type " + constructor.getDeclaringClass(), 
e);
+        throw new ForyJsonException("Cannot create SQL JSON type " + type, e);
+      } catch (Throwable e) {
+        throw new ForyJsonException("Cannot create SQL JSON type " + type, e);
       }

Review Comment:
   **[Suggestion]** The `catch (ReflectiveOperationException e)` block is 
redundant — it is entirely subsumed by the subsequent `catch (Throwable e)` 
block, and both perform the identical wrapping. — Concrete cost: any future 
change to error handling (e.g., adding context, unwrapping 
`InvocationTargetException`) must be applied in two places or the blocks 
silently diverge.
   
   ```suggestion
       } catch (Throwable e) {
         throw new ForyJsonException("Cannot create SQL JSON type " + type, e);
       }
   ```
   
   _— qwen3-coder-plus via Qwen Code /review_



##########
java/fory-json/src/main/java/org/apache/fory/json/JsonGeneratedClassRegistry.java:
##########
@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fory.json;
+
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import org.apache.fory.annotation.Internal;
+import org.apache.fory.json.resolver.JsonSharedRegistry.GeneratedClasses;
+import org.apache.fory.reflect.TypeRef;
+
+/** Frozen Native Image mapping from JSON configuration semantics to generated 
classes. */
+@Internal
+public final class JsonGeneratedClassRegistry {
+  private static Map<JsonCodegenKey, MutableConfiguration> pending = new 
HashMap<>();
+  private static Map<JsonCodegenKey, Configuration> configurations = 
Collections.emptyMap();

Review Comment:
   **[Suggestion]** `configurations` is written under `synchronized` in 
`register()` but read without synchronization or `volatile` in the public 
`configuration()` method — a JMM data race on the reference. In the current 
GraalVM-only lifecycle the native-image heap-snapshot provides a happens-before 
edge, so the race does not manifest. However, `configuration()` is `@Internal 
public` and called from 12 unsynchronized sites in `JsonSharedRegistry`. If any 
future code path calls `configuration()` concurrently with `register()` without 
an external synchronization barrier, the reading thread can see the stale 
`Collections.emptyMap()` initial value. — Concrete cost: every `native*Class()` 
lookup returns `null`, silently falling back to interpreted codecs.
   
   ```suggestion
     private static volatile Map<JsonCodegenKey, Configuration> configurations 
= Collections.emptyMap();
   ```
   
   _— qwen3-coder-plus via Qwen Code /review_



##########
java/fory-json/src/main/java17/org/apache/fory/json/ForyJsonGraalVMFeature.java:
##########
@@ -114,17 +147,218 @@ public void duringAnalysis(DuringAnalysisAccess access) {
         if (mixin != null) {
           changed |= registerMixin(access, type, mixin.target());
         }
+        if (type.getDeclaredAnnotation(ForyJsonProvider.class) != null) {
+          changed |= registerProvider(type);
+        }
         if (type == ForyJson.class) {
           registerBuiltInTypes(access);
           changed = true;
         }
       }
     }
+    changed |= generateConfigurations(access);
     if (changed) {
       access.requireAnalysisIteration();
     }
   }
 
+  private boolean registerProvider(Class<?> providerClass) {
+    if (!processedProviders.add(providerClass)) {
+      return false;
+    }
+    int modifiers = providerClass.getModifiers();
+    if (!Modifier.isPublic(modifiers)
+        || Modifier.isAbstract(modifiers)
+        || providerClass.isInterface()
+        || providerClass.isEnum()) {
+      throw providerFailure(
+          providerClass, "must be a public concrete class", null);
+    }
+    Constructor<?> constructor;
+    try {
+      constructor = providerClass.getConstructor();
+    } catch (NoSuchMethodException e) {
+      throw providerFailure(providerClass, "must have a public no-argument 
constructor", e);
+    }
+    Object provider;
+    try {
+      provider = constructor.newInstance();
+    } catch (ReflectiveOperationException | RuntimeException e) {
+      throw providerFailure(providerClass, "cannot be constructed", unwrap(e));
+    }
+    List<Method> methods = providerMethods(providerClass);
+    if (methods.isEmpty()) {
+      throw providerFailure(providerClass, "does not declare an effective 
ForyJson method", null);
+    }
+    boolean changed = false;
+    for (Method method : methods) {
+      if (Modifier.isStatic(method.getModifiers()) || 
method.getParameterCount() != 0) {
+        throw providerFailure(
+            providerClass,
+            "method must be a non-static zero-argument instance method: " + 
method,
+            null);
+      }
+      ForyJson json;
+      try {
+        json = (ForyJson) method.invoke(provider);
+      } catch (ReflectiveOperationException | RuntimeException e) {
+        throw providerFailure(
+            providerClass, "cannot invoke provider method " + method, 
unwrap(e));
+      }
+      if (json == null) {
+        throw providerFailure(providerClass, "provider method returned null: " 
+ method, null);
+      }
+      JsonConfig config = json.config();
+      if (!config.codegenEnabled()) {
+        throw providerFailure(
+            providerClass, "provider method returned a codegen-disabled 
ForyJson: " + method, null);
+      }
+      JsonCodegenKey key = config.codegenKey();
+      if (!hostedConfigurations.containsKey(key)) {
+        hostedConfigurations.put(key, new HostedConfiguration(config));
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  private static List<Method> providerMethods(Class<?> providerClass) {
+    Map<MethodSignature, Method> effective = new HashMap<>();
+    for (Method method : providerClass.getMethods()) {
+      if (method.isBridge()
+          || method.isSynthetic()
+          || method.getReturnType() != ForyJson.class) {
+        continue;
+      }
+      MethodSignature signature = new MethodSignature(method);
+      Method previous = effective.get(signature);
+      if (previous == null
+          || 
previous.getDeclaringClass().isAssignableFrom(method.getDeclaringClass())) {
+        effective.put(signature, method);
+      } else if 
(!method.getDeclaringClass().isAssignableFrom(previous.getDeclaringClass())
+          && 
method.getDeclaringClass().getName().compareTo(previous.getDeclaringClass().getName())
+              < 0) {
+        effective.put(signature, method);
+      }
+    }
+    ArrayList<Method> methods = new ArrayList<>(effective.values());
+    methods.sort(
+        Comparator.comparing(Method::getName)
+            .thenComparing(method -> method.getDeclaringClass().getName())
+            .thenComparing(Method::toGenericString));
+    return methods;
+  }
+
+  private boolean generateConfigurations(DuringAnalysisAccess access) {

Review Comment:
   **[Suggestion]** Unused `DuringAnalysisAccess access` parameter — the method 
body never references `access`; it works entirely through instance fields 
(`hostedConfigurations`, `processedModels`, `reachableMixins`, 
`processedGenerations`). This is dead code left over from the removed 
`registerGeneratedCodec` path that used `access.findClassByName`. — Concrete 
cost: compiling with `-Xlint:unused` flags this as a warning, and a `-Werror` 
CI configuration would fail the build; the parameter also creates false 
coupling at the call site.
   
   ```suggestion
     private boolean generateConfigurations() {
   ```
   
   _— qwen3-coder-plus via Qwen Code /review_



##########
java/fory-json/src/main/java17/org/apache/fory/json/JsonCreatorCodegen.java:
##########
@@ -0,0 +1,442 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fory.json;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.fory.platform.internal.DefineClass;
+import org.apache.fory.platform.internal._JDKAccess;
+
+/** Generates direct constructor invokers while Native Image analysis is still 
mutable. */
+final class JsonCreatorCodegen {
+  private static final int ACC_PUBLIC = 0x0001;
+  private static final int ACC_STATIC = 0x0008;
+  private static final int ACC_FINAL = 0x0010;
+  private static final int ACC_SUPER = 0x0020;
+  private static final int ACC_SYNTHETIC = 0x1000;
+
+  private JsonCreatorCodegen() {}
+
+  static Invokers create(Constructor<?> constructor) {
+    Class<?> ownerType = constructor.getDeclaringClass();
+    Class<?> invokerClass =
+        DefineClass.defineHiddenNestmate(ownerType, new 
ClassBytes(constructor).build());
+    try {
+      MethodHandles.Lookup lookup = _JDKAccess._trustedLookup(invokerClass);
+      MethodHandle creator =
+          lookup.findStatic(
+              invokerClass,
+              "invoke",
+              MethodType.methodType(Object.class, Object[].class));
+      Method creatorMethod = invokerClass.getDeclaredMethod("invoke", 
Object[].class);
+      if (constructor.getParameterCount() != 1
+          || constructor.getParameterTypes()[0] != String.class) {
+        return new Invokers(invokerClass, creator, creatorMethod, null, null);
+      }
+      MethodHandle stringCreator =
+          lookup.findStatic(
+              invokerClass,
+              "invoke",
+              MethodType.methodType(Object.class, String.class));
+      Method stringMethod = invokerClass.getDeclaredMethod("invoke", 
String.class);
+      return new Invokers(invokerClass, creator, creatorMethod, stringCreator, 
stringMethod);
+    } catch (ReflectiveOperationException cause) {
+      throw new IllegalStateException(
+          "Cannot resolve generated Fory JSON creator for " + constructor, 
cause);
+    }
+  }
+
+  static final class Invokers {
+    final Class<?> type;
+    final MethodHandle creator;
+    final Method creatorMethod;
+    final MethodHandle stringCreator;
+    final Method stringMethod;
+
+    private Invokers(
+        Class<?> type,
+        MethodHandle creator,
+        Method creatorMethod,
+        MethodHandle stringCreator,
+        Method stringMethod) {
+      this.type = type;
+      this.creator = creator;
+      this.creatorMethod = creatorMethod;
+      this.stringCreator = stringCreator;
+      this.stringMethod = stringMethod;
+    }
+  }
+
+  private static final class ClassBytes {
+    private static final String OBJECT = "java/lang/Object";
+    private static final String OBJECT_ARRAY_INVOKE = 
"([Ljava/lang/Object;)Ljava/lang/Object;";
+    private static final String STRING_INVOKE = 
"(Ljava/lang/String;)Ljava/lang/Object;";
+
+    private final Constructor<?> constructor;
+    private final Class<?>[] parameterTypes;
+    private final String owner;
+    private final String generatedName;
+    private final boolean stringCreator;
+    private final ConstantPool constants = new ConstantPool();
+
+    private ClassBytes(Constructor<?> constructor) {
+      this.constructor = constructor;
+      parameterTypes = constructor.getParameterTypes();
+      owner = internalName(constructor.getDeclaringClass());
+      generatedName = owner + "$$ForyJsonCreator";
+      stringCreator = parameterTypes.length == 1 && parameterTypes[0] == 
String.class;
+    }
+
+    private byte[] build() {
+      try {
+        int thisClass = constants.classInfo(generatedName);
+        int superClass = constants.classInfo(OBJECT);
+        MethodCode arrayInvoker = arrayInvoker();
+        MethodCode stringInvoker = stringCreator ? stringInvoker() : null;
+        arrayInvoker.register(constants);
+        if (stringCreator) {
+          stringInvoker.register(constants);
+        }
+
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        DataOutputStream output = new DataOutputStream(bytes);
+        output.writeInt(0xCAFEBABE);
+        output.writeShort(0);
+        output.writeShort(52);
+        constants.write(output);
+        output.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER | ACC_SYNTHETIC);
+        output.writeShort(thisClass);
+        output.writeShort(superClass);
+        output.writeShort(0);
+        output.writeShort(0);
+        output.writeShort(stringCreator ? 2 : 1);
+        arrayInvoker.write(output, constants);
+        if (stringCreator) {
+          stringInvoker.write(output, constants);
+        }
+        output.writeShort(0);
+        output.flush();
+        return bytes.toByteArray();
+      } catch (IOException cause) {
+        throw new IllegalStateException("Cannot generate Fory JSON creator for 
" + constructor, cause);
+      }
+    }
+
+    private MethodCode arrayInvoker() throws IOException {
+      Code code = new Code(constants);
+      code.type(0xbb, owner);
+      code.op(0x59);
+      for (int i = 0; i < parameterTypes.length; i++) {
+        code.op(0x2a);
+        code.integer(i);
+        code.op(0x32);
+        code.convert(parameterTypes[i]);
+      }
+      code.method(0xb7, owner, "<init>", 
constructorDescriptor(parameterTypes));
+      code.op(0xb0);
+      return new MethodCode(
+          ACC_PUBLIC | ACC_STATIC,
+          "invoke",
+          OBJECT_ARRAY_INVOKE,
+          4 + parameterTypes.length * 2,
+          1,
+          code.bytes());
+    }
+
+    private MethodCode stringInvoker() throws IOException {
+      Code code = new Code(constants);
+      code.type(0xbb, owner);
+      code.op(0x59);
+      code.op(0x2a);
+      code.method(0xb7, owner, "<init>", 
constructorDescriptor(parameterTypes));
+      code.op(0xb0);
+      return new MethodCode(
+          ACC_PUBLIC | ACC_STATIC, "invoke", STRING_INVOKE, 3, 1, 
code.bytes());
+    }
+  }
+
+  private static final class MethodCode {
+    private final int access;
+    private final String name;
+    private final String descriptor;
+    private final int maxStack;
+    private final int maxLocals;
+    private final byte[] code;
+
+    private MethodCode(
+        int access, String name, String descriptor, int maxStack, int 
maxLocals, byte[] code) {
+      this.access = access;
+      this.name = name;
+      this.descriptor = descriptor;
+      this.maxStack = maxStack;
+      this.maxLocals = maxLocals;
+      this.code = code;
+    }
+
+    private void write(DataOutputStream output, ConstantPool constants) throws 
IOException {
+      output.writeShort(access);
+      output.writeShort(constants.utf8(name));
+      output.writeShort(constants.utf8(descriptor));
+      output.writeShort(1);
+      output.writeShort(constants.utf8("Code"));
+      output.writeInt(12 + code.length);
+      output.writeShort(maxStack);
+      output.writeShort(maxLocals);
+      output.writeInt(code.length);
+      output.write(code);
+      output.writeShort(0);
+      output.writeShort(0);
+    }
+
+    private void register(ConstantPool constants) {
+      constants.utf8(name);
+      constants.utf8(descriptor);
+      constants.utf8("Code");
+    }
+  }
+
+  private static final class Code {
+    private static final Map<Class<?>, Class<?>> BOX_TYPES = boxTypes();
+    private final ConstantPool constants;
+    private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+    private final DataOutputStream output = new DataOutputStream(bytes);
+
+    private Code(ConstantPool constants) {
+      this.constants = constants;
+    }
+
+    private void op(int opcode) throws IOException {
+      output.writeByte(opcode);
+    }
+
+    private void type(int opcode, String type) throws IOException {
+      output.writeByte(opcode);
+      output.writeShort(constants.classInfo(type));
+    }
+
+    private void method(int opcode, String owner, String name, String 
descriptor)
+        throws IOException {
+      output.writeByte(opcode);
+      output.writeShort(constants.methodRef(owner, name, descriptor));
+    }
+
+    private void integer(int value) throws IOException {
+      if (value <= 5) {
+        output.writeByte(0x03 + value);
+      } else if (value <= Byte.MAX_VALUE) {
+        output.writeByte(0x10);
+        output.writeByte(value);
+      } else {
+        output.writeByte(0x11);
+        output.writeShort(value);
+      }
+    }
+
+    private void convert(Class<?> type) throws IOException {
+      if (!type.isPrimitive()) {
+        if (type != Object.class) {
+          this.type(0xc0, internalName(type));
+        }
+        return;
+      }
+      Class<?> boxType = BOX_TYPES.get(type);
+      this.type(0xc0, internalName(boxType));

Review Comment:
   **[Suggestion]** `JsonCreatorCodegen` emits unboxing bytecode for 8 
primitive types but only `int` is exercised through `@JsonCreator` constructors 
in the integration tests; `long`, `double`, `boolean`, `byte`, `short`, `char`, 
and `float` paths have no test coverage. — Concrete cost: if a future change to 
`convert()` or `boxTypes()` introduces a wrong box type or unboxing method for 
`long`, a `@JsonCreator` with a `long` parameter would produce a `VerifyError` 
or silent value truncation in the native image with no test to catch it.
   
   Consider adding a `@JsonCreator` model to `ForyJsonExample` that exercises 
at least `long` and `double` constructor parameters.
   
   _— qwen3-coder-plus via Qwen Code /review_



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to