Exclude compiler-owned declarations however they got into the set.

The affected set is seeded from the functions which ask for a stack trace
before any filtering happens, so filtering what the traversal adds missed an
intrinsic seeded that way. Jass removed those and Lua did not, and on Lua the
signature check then failed the build rather than letting the lowering quietly
not happen - either way -lua -stacktraces was broken for that input.

The removal now happens once, after both branches.

Author: Frotty

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

@@ -124,19 +124,23 @@ public void visit(ImFuncRef imFuncRef) {
                 .filter((ImFunction f) ->
                     !f.hasFlag(FunctionFlagEnum.IS_NATIVE)
                         && !f.hasFlag(FunctionFlagEnum.IS_BJ)
-                        && !f.hasFlag(FunctionFlagEnum.IS_EXTERN)
-                        && !isCompilerOwned(f))
+                        && !f.hasFlag(FunctionFlagEnum.IS_EXTERN))
                 .collect(Collectors.toCollection(() -> affectedFuncs));
             affectedFuncs.removeAll(configOnlyFuncs);
 
         } else {
             for (ImFunction stackTraceUse : stackTraceGets.keys()) {
                 callRelationTr.get(stackTraceUse).forEach(affectedFuncs::add);
             }
-            affectedFuncs.removeIf(StackTraceInjector2::isCompilerOwned);
         }
 
 
+        // After both branches, and after the seeding from stackTraceGets above: a declaration
+        // the compiler owns is never instrumented, however it came to be in the set. Filtering
+        // only what each branch adds would miss one seeded there by its own use of a stack trace,
+        // and would then trip the check below rather than doing nothing.
+        affectedFuncs.removeIf(StackTraceInjector2::isCompilerOwned);
+
         passStacktraceParams(calls, affectedFuncs);
         addStackTracePush(calls, affectedFuncs);
         addStackTracePop(affectedFuncs);

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

@@ -2073,6 +2073,35 @@ public void stackTracesLeaveCompilerOwnedDeclarationsAlone() throws IOException
         assertTrue("stack traces must actually be on", compiled.contains("wurst_stack_depth"));
     }
 
+    /**
+     * The rule has to hold for an intrinsic which asks for a stack trace itself.
+     *
+     * <p>Such a function is seeded into the affected set before any filtering, so excluding only
+     * what the traversal adds would leave it instrumented - and the signature check would then
+     * fail the build rather than let the lowering quietly not happen. Either way `-lua
+     * -stacktraces` would be broken for this input.
+     */
+    @Test
+    public void aCompilerOwnedDeclarationUsingAStackTraceIsStillLeftAlone() throws IOException {
+        test().testLua(true).stacktraces().withStdLib().lines(
+            "package Test",
+            "@compilerintrinsic public function wurstTraced(int a) returns string",
+            "    return getStackTraceString() + a.toString()",
+            "init",
+            "    print(wurstTraced(1))",
+            "endpackage");
+
+        String compiled = Files.toString(
+            new File("test-output/lua/LuaTranslationTests_aCompilerOwnedDeclarationUsingAStackTraceIsStillLeftAlone.lua"),
+            Charsets.UTF_8);
+
+        String signature = compiled.substring(compiled.indexOf("function wurstTraced"));
+        signature = signature.substring(0, signature.indexOf(")") + 1);
+        assertFalse("a compiler-owned declaration must not gain a trace parameter: " + signature,
+            signature.contains("stackPos"));
+        assertTrue("stack traces must actually be on", compiled.contains("wurst_stack_depth"));
+    }
+
     @Test
     public void keyedTableStaysNativeWithStackTraces() throws IOException {
         test().testLua(true).stacktraces().inline().withStdLib().lines(keyedTableSource(