isLua magic constant

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/WurstKeywords.java

@@ -8,7 +8,7 @@ public class WurstKeywords {
             "tuple", "div", "mod", "let", "from", "to", "downto", "step", "endpackage", "skip", "true", "false", "var", "instanceof",
             "super", "enum", "switch", "case", "default", "typeId", "begin", "end",
             // not really a keyword, but it should feel like one:
-            "compiletime",
+            "compiletime", "isLua",
             // jurst keywords, maybe split the highlighters later...:
             "library", "endlibrary", "scope", "endscope", "requires", "uses", "needs", "struct", "endstruct",
             "then", "endif", "loop", "exitwhen", "endloop", "method", "takes", "endmethod", "set", "call",

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imoptimizer/GlobalsInliner.java

@@ -13,7 +13,6 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 public class GlobalsInliner implements OptimizerPass {
     public int optimize(ImTranslator trans) {
@@ -28,6 +27,21 @@ public int optimize(ImTranslator trans) {
                 // so it is important, that we do not optimize away the compiletime constant
                 continue;
             }
+            if (v.getName().equals("MagicFunctions_isLua") && trans.isLuaTarget()) {
+                // In Lua mode, isLua must evaluate to true.
+                // Normal inlining would use the declared value (false); override it here.
+                for (ImVarRead read : new ArrayList<>(v.attrReads())) {
+                    read.replaceBy(JassIm.ImBoolVal(true));
+                }
+                for (ImVarWrite write : new ArrayList<>(v.attrWrites())) {
+                    if (write.getParent() != null) {
+                        write.replaceBy(ImHelper.nullExpr());
+                    }
+                }
+                obsoleteVars.add(v);
+                obsoleteCount++;
+                continue;
+            }
             if (v.getType() instanceof ImArrayType
                 || v.getType() instanceof ImArrayTypeMulti) {
                 // cannot optimize arrays yet

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

@@ -83,6 +83,20 @@ private LuaNativeLowering() {}
      * functions, most of which are unreachable in any given program).
      */
     public static void transform(ImProg prog) {
+        // Replace all reads of MagicFunctions_isLua with true.
+        // This must happen before any optimizer passes so that dead-code elimination
+        // can remove Jass-only branches at compile time.
+        // We use attrReads() (not a visitor) to target only rvalue uses, avoiding
+        // ClassCastException when the same ImVarAccess appears as a write target (lvalue).
+        for (ImVar global : prog.getGlobals()) {
+            if ("MagicFunctions_isLua".equals(global.getName())) {
+                for (ImVarRead read : new ArrayList<>(global.attrReads())) {
+                    read.replaceBy(JassIm.ImBoolVal(true));
+                }
+                break;
+            }
+        }
+
         // Maps original BJ function → replacement (IS_NATIVE stub or nil-safety wrapper).
         // Populated lazily during the traversal.
         Map<ImFunction, ImFunction> replacements = new LinkedHashMap<>();

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

@@ -116,15 +116,20 @@ public static LuaExpr translate(ImFunctionCall e, LuaTranslator tr) {
         }
 
         LuaFunction f = tr.luaFunc.getFor(e.getFunc());
-        if ("I2S".equals(f.getName()) && isIntentionalThreadAbortCall(e)) {
+        // Use the immutable ImFunction name rather than f.getName(), because f is a cached
+        // LuaFunction object shared across all call sites of this native. The setName() calls
+        // below mutate it, so f.getName() changes after the first translation and can no longer
+        // be relied upon for sentinel checks.
+        String imFuncName = e.getFunc().getName();
+        if ("I2S".equals(imFuncName) && isIntentionalThreadAbortCall(e)) {
             return LuaAst.LuaExprFunctionCallByName("error", LuaAst.LuaExprlist(
                 LuaAst.LuaExprStringVal(WURST_ABORT_THREAD_SENTINEL),
                 LuaAst.LuaExprIntVal("0")
             ));
         }
-        if (f.getName().equals(ImTranslator.$DEBUG_PRINT)) {
+        if (ImTranslator.$DEBUG_PRINT.equals(imFuncName)) {
             f.setName("BJDebugMsg");
-        } else if (f.getName().equals("I2S")) {
+        } else if ("I2S".equals(imFuncName)) {
             f.setName("tostring");
         }
         return LuaAst.LuaExprFunctionCall(f, tr.translateExprList(e.getArguments()));

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

@@ -2124,6 +2124,31 @@ public void i2sDivisionByZeroCrashTrapUsesAbortSentinelInLua() throws IOExceptio
         assertDoesNotContainRegex(compiled, "error\\s*\\(\\s*\"[^\"]*divide by zero[^\"]*\"");
     }
 
+    @Test
+    public void i2sAbortSentinelNotBrokenByEarlierI2SCallInLua() throws IOException {
+        // Regression: ExprTranslation used f.setName("tostring") to rename the shared
+        // LuaFunction for I2S. After the first ordinary I2S(x) call was translated, f.getName()
+        // returned "tostring", so the sentinel check "I2S".equals(f.getName()) silently failed
+        // for any later I2S(1/0) abort call — leaving actual //0 division in the Lua output.
+        // This test forces a normal I2S call before the abort to expose the mutation bug.
+        test().testLua(true).withStdLib().lines(
+            "package Test",
+            "import MagicFunctions",
+            "import ErrorHandling",
+            "init",
+            "    let x = 42",
+            "    print(I2S(x))",   // normal I2S call first — used to corrupt the cached LuaFunction
+            "    error(\"test\")"  // triggers I2S(1 div 0) inside ErrorHandling.error()
+        );
+        String compiled = Files.toString(new File("test-output/lua/LuaTranslationTests_i2sAbortSentinelNotBrokenByEarlierI2SCallInLua.lua"), Charsets.UTF_8);
+        // The abort must be the sentinel, not a raw //0 that Lua would crash on at runtime
+        assertDoesNotContainRegex(compiled, "tostring\\s*\\(\\s*1\\s*//\\s*0\\s*\\)");
+        assertDoesNotContainRegex(compiled, "tostring\\s*\\(\\s*1\\s*/\\s*0\\s*\\)");
+        assertTrue(compiled.contains("__wurst_abort_thread"));
+        // tostring() must still be used for the normal I2S call
+        assertContainsRegex(compiled, "tostring\\s*\\(");
+    }
+
     @Test
     public void luaErrorWrapperIgnoresAbortSentinel() throws IOException {
         test().testLua(true).withStdLib().lines(
@@ -2290,4 +2315,26 @@ public void wurstInternalNativesDoNotGetNilSafetyWrapper() throws IOException {
         assertDoesNotContainRegex(compiled, "__wurst_safe___wurst_");
     }
 
+    @Test
+    public void isLuaMagicConstantIsTrueInLuaMode() throws IOException {
+        // isLua must be inlined to true in Lua mode by GlobalsInliner,
+        // so backend-specific code paths can be selected at compile time.
+        test().testLua(true).withStdLib().lines(
+            "package Test",
+            "import MagicFunctions",
+            "init",
+            "    if isLua",
+            "        print(\"lua-path\")",
+            "    else",
+            "        print(\"jass-path\")"
+        );
+        String compiled = Files.toString(
+            new File("test-output/lua/LuaTranslationTests_isLuaMagicConstantIsTrueInLuaMode.lua"),
+            Charsets.UTF_8);
+        // After inlining, the raw isLua variable must not appear in Lua output
+        assertFalse("MagicFunctions_isLua must be inlined away in Lua mode", compiled.contains("MagicFunctions_isLua"));
+        // The lua-path branch must be preserved
+        assertTrue("lua-path branch must be present", compiled.contains("lua-path"));
+    }
+
 }