build fixes

Author: Frotty

de.peeeq.wurstscript/build.gradle

@@ -39,6 +39,7 @@ def j25Launcher = toolchainSvc.launcherFor(java.toolchain)
 
 tasks.withType(JavaExec).configureEach {
     javaLauncher.set(j25Launcher)
+    jvmArgs('-XX:+UnlockExperimentalVMOptions', '-XX:+UseCompactObjectHeaders')
 }
 
 tasks.withType(JavaCompile).configureEach { options.release = 25 }
@@ -244,6 +245,8 @@ test {
             '-Xmx2g',                         // local: give it room to finish and dump
             '-XX:MaxMetaspaceSize=256m',
             '-XX:+HeapDumpOnOutOfMemoryError',
+            '-XX:+UnlockExperimentalVMOptions', // needed for UseCompactObjectHeaders until it graduates
+            '-XX:+UseCompactObjectHeaders',    // Java 24+: 8-byte headers (vs 16) — big win for AST-heavy workloads
     )
 }
 

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/LuaNativeLowering.java

@@ -18,14 +18,14 @@
  *       <b>context-callback natives</b> ({@code ForForce}, {@code ForGroup}, …) –
  *       replaced 1:1 by their {@code __wurst_} prefixed equivalents, whose Lua
  *       implementations are provided by {@link de.peeeq.wurstscript.translation.lua.translation.LuaNatives}.</li>
- *   <li><b>Non-native blizzard.j BJ functions with at least one handle-typed parameter</b>
- *       – wrapped by a generated IM function that first checks each handle param for
+ *   <li><b>All other BJ calls with at least one handle-typed parameter</b> – wrapped
+ *       by a generated IM function that first checks each required handle param for
  *       {@code null} and returns the type-appropriate default (0 / 0.0 / false / "" / nil),
  *       then delegates to the original BJ function.  This matches Jass behavior, which
  *       silently returns defaults on null-handle calls instead of crashing.
- *       Common.j natives are intentionally excluded: they either accept {@code nil} natively
- *       (e.g. {@code TriggerRegisterPlayerUnitEvent} with a null filter) or are already
- *       covered by categories 1 and 2 above.</li>
+ *       {@code boolexpr} and {@code code} typed params are intentionally skipped: these
+ *       are optional/nullable in Jass (e.g. the filter arg of
+ *       {@code TriggerRegisterPlayerUnitEvent}) and passing {@code nil} is valid.</li>
  * </ol>
  *
  * <p>IS_NATIVE stubs added for category 1 and 2 are recognised by
@@ -197,7 +197,7 @@ private ImFunction computeReplacement(ImFunction bj) {
                     return createNativeStub("__wurst_" + name, bj);
                 } else if (CONTEXT_CALLBACK_NATIVE_NAMES.contains(name)) {
                     return createNativeStub("__wurst_" + name, bj);
-                } else if (hasHandleParam(bj) && !bj.isNative()) {
+                } else if (hasHandleParam(bj)) {
                     return createNilSafeWrapper(bj);
                 }
                 return null;
@@ -247,10 +247,12 @@ private static ImFunction createNilSafeWrapper(ImFunction bjNative) {
 
         ImStmts body = JassIm.ImStmts();
 
-        // Null-check each handle param: if param == null then return <default> end
+        // Null-check each required handle param: if param == null then return <default> end
+        // boolexpr and code params are intentionally skipped — they are optional/nullable
+        // in Jass (e.g. the filter arg of TriggerRegisterPlayerUnitEvent).
         ImExpr returnDefault = defaultValueExpr(bjNative.getReturnType());
         for (ImVar param : paramVars) {
-            if (isHandleType(param.getType())) {
+            if (isHandleType(param.getType()) && !isNullableHandleType(param.getType())) {
                 ImExpr condition = JassIm.ImOperatorCall(WurstOperator.EQ, JassIm.ImExprs(
                     JassIm.ImVarAccess(param),
                     JassIm.ImNull(param.getType().copy())
@@ -304,6 +306,22 @@ static boolean isHandleType(ImType type) {
         return !n.equals("integer") && !n.equals("real") && !n.equals("boolean") && !n.equals("string");
     }
 
+    /**
+     * Returns true for handle types that are valid to pass as {@code null} in Jass without
+     * triggering a null-handle crash.  These params are skipped in nil-safety wrappers.
+     *
+     * <p>{@code boolexpr} and {@code code} are the canonical optional types: every WC3
+     * API that takes them (filter, condition, action callbacks) accepts {@code null} to
+     * mean "no callback".
+     */
+    static boolean isNullableHandleType(ImType type) {
+        if (!(type instanceof ImSimpleType)) {
+            return false;
+        }
+        String n = ((ImSimpleType) type).getTypename();
+        return n.equals("boolexpr") || n.equals("code");
+    }
+
     private static boolean shouldRewriteGetHandleId(ImFunctionCall call) {
         if (call.getArguments().size() != 1) {
             return true;
@@ -320,9 +338,14 @@ public static boolean usesLuaObjectIdentityHandleId(ImType type) {
     }
 
     private static boolean isCompatGetHandleIdFunction(ImFunction f) {
-        return f.getParameters().size() == 1
-            && f.getName().endsWith("_getHandleId")
-            && !f.getName().endsWith("_getTCHandleId");
+        if (f.getParameters().size() != 1
+            || !f.getName().endsWith("_getHandleId")
+            || f.getName().endsWith("_getTCHandleId")) {
+            return false;
+        }
+        // Restrict to WC3 simple handle types (ImSimpleType). User-defined Wurst classes
+        // use ImClassType and must not have their call sites replaced.
+        return isHandleType(f.getParameters().get(0).getType());
     }
 
     /** Returns an IM expression representing the safe default for the given return type. */

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/lua/translation/LuaTranslator.java

@@ -520,6 +520,11 @@ private boolean rewriteGetHandleIdCompatFunction(ImFunction f, LuaFunction lf) {
             return false;
         }
         ImVar firstParam = f.getParameters().get(0);
+        // Restrict to WC3 simple handle types. User-defined Wurst classes use ImClassType
+        // and must not have their function body replaced.
+        if (!LuaNativeLowering.isHandleType(firstParam.getType())) {
+            return false;
+        }
         LuaExpr arg = LuaAst.LuaExprVarAccess(luaVar.getFor(firstParam));
         // Only called when ENABLE_SELECTIVE_GET_HANDLE_ID_SHIMMING is true.
         // Shim opaque runtime handles; keep native GetHandleId for enum-like handles.

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaTranslationTests.java

@@ -2475,7 +2475,7 @@ public void getHandleIdAssertionDoesNotFalsePositiveOnDeclarations() {
 
     @Test
     public void externNativesWithHandleParamsGetNilSafetyWrapper() throws IOException {
-        // BJ natives (IS_BJ) with handle-type parameters must be wrapped at the IM level
+        // IS_BJ functions with handle-type parameters must be wrapped at the IM level
         // so that passing nil returns a safe default instead of crashing the Lua runtime.
         // GetUnitTypeId is a common.j native (IS_BJ) with a handle param, returns integer.
         // Result is used in print() so the optimizer does not dead-code-eliminate the call.