Add dedicated test coverage for root-level code with no function main() (#294)

* Add tests for plain function and type alias cross-module exports/imports

* Add dedicated test coverage for root-level code with no function main()

When a file has no explicit main(), generateGlobalEntryCode
(MLIRGenModule.cpp) gathers every statement not inside a function/class body
and compiles it AS the synthesized main() itself. ~54 existing test files
incidentally rely on this (root-level assert/print calls with no main
wrapper), but they're all short/simple - none deliberately exercised control
flow at true root scope. 44toplevelcode.ts has top-level declarations but
still wraps its actual test logic in an explicit main().

Also notable: a `let`/`const` declared directly at root level is module-scope
storage (like a static field), not a stack local - a real difference from
the normal case worth covering, especially for closures capturing it.

Added:
- 00toplevel_control_flow.ts: for/while/switch/try-catch-finally running
  directly at root scope, a closure capturing a root-level `let`, and a
  class defined and used at root (instantiated, method called).
- 00toplevel_no_main_with_helpers.ts: root-level statements coexisting with
  ordinary function/class declarations, calling into them.

Registered in both compile and jit tiers (4 new add_test entries), next to
the existing 44toplevelcode.ts registration.

Investigation note: hit what looked like a real bug along the way - JIT
crashed with an uncaught C++ exception on the try/catch block, AOT produced
no output at all. Root cause was in the test, not the compiler: `throw 42;`
throws an integer literal, but `catch (v: number)` expects `number` (f64),
and catch-by-type requires an exact type match - the exception propagated
uncaught. Fixed to `throw 42.0;`, matching the established idiom in
00try_catch.ts's main2(), and confirmed passing in both tiers before adding.

827/827 tests green (823 + these 4 new entries).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: ASDAlexander77

tslang/test/tester/CMakeLists.txt

@@ -425,6 +425,13 @@ add_test(NAME test-compile-41-anonymoustypes COMMAND test-runner "${PROJECT_SOUR
 add_test(NAME test-compile-42-lambdaproperties COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/42lambdaproperties.ts")
 add_test(NAME test-compile-43-nestednamespace COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/43nestednamespace.ts")
 add_test(NAME test-compile-44-toplevelcode COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/44toplevelcode.ts")
+# 44toplevelcode.ts has top-level declarations but wraps its actual test logic in an
+# explicit main() - these two exercise executable statements running directly at root
+# scope with NO main() anywhere (generateGlobalEntryCode compiles the root statements
+# AS the synthesized `main` itself): control flow (for/while/switch/try-catch-finally)
+# plus a closure capturing a root-level `let` (module-scope storage, not a stack local).
+add_test(NAME test-compile-00-toplevel-control-flow COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00toplevel_control_flow.ts")
+add_test(NAME test-compile-00-toplevel-no-main-with-helpers COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00toplevel_no_main_with_helpers.ts")
 add_test(NAME test-compile-45-enumtostring COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/45enumtostring.ts")
 add_test(NAME test-compile-48-instanceof COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/48instanceof.ts")
 add_test(NAME test-compile-51-exceptions COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/51exceptions.ts")
@@ -793,6 +800,8 @@ add_test(NAME test-jit-41-anonymoustypes COMMAND test-runner -jit "${PROJECT_SOU
 add_test(NAME test-jit-42-lambdaproperties COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/42lambdaproperties.ts")
 add_test(NAME test-jit-43-nestednamespace COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/43nestednamespace.ts")
 add_test(NAME test-jit-44-toplevelcode COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/44toplevelcode.ts")
+add_test(NAME test-jit-00-toplevel-control-flow COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00toplevel_control_flow.ts")
+add_test(NAME test-jit-00-toplevel-no-main-with-helpers COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00toplevel_no_main_with_helpers.ts")
 add_test(NAME test-jit-45-enumtostring COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/45enumtostring.ts")
 add_test(NAME test-jit-48-instanceof COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/48instanceof.ts")
 add_test(NAME test-jit-51-exceptions COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/51exceptions.ts")

tslang/test/tester/tests/00toplevel_control_flow.ts

@@ -0,0 +1,71 @@
+// Root-level executable code with NO `function main()` anywhere in the file.
+// When there's no explicit `main`, generateGlobalEntryCode (MLIRGenModule.cpp)
+// gathers every statement that isn't inside a function/class body and compiles
+// it AS the synthesized `main` function itself - so this exercises the same
+// control-flow/closure/exception codegen every other test exercises inside an
+// explicit main(), just routed through the auto-synthesis path instead.
+// Also: a `let`/`const` declared directly at this level is module-scope
+// storage (like a static field), not a stack local - so the closure test
+// below captures a GLOBAL, not a stack frame slot.
+
+let sum = 0;
+for (let i = 0; i < 5; i++) {
+    if (i == 2) continue;
+    if (i == 4) break;
+    sum = sum + i;
+}
+assert(sum == 4, "for-if-continue-break");
+
+let count = 0;
+while (count < 3) {
+    count = count + 1;
+}
+assert(count == 3, "while");
+
+let label = "";
+switch (count) {
+    case 1:
+        label = "one";
+        break;
+    case 3:
+        label = "three";
+        break;
+    default:
+        label = "other";
+        break;
+}
+assert(label == "three", "switch");
+
+let caught = false;
+try {
+    throw 42.0;
+} catch (v: number) {
+    caught = v == 42;
+} finally {
+    sum = sum + 100;
+}
+assert(caught, "try-catch");
+assert(sum == 104, "finally-ran");
+
+let counter = 0;
+const increment = () => {
+    counter = counter + 1;
+};
+increment();
+increment();
+assert(counter == 2, "closure-capture-root-let");
+
+class Counter {
+    value: number = 0;
+    increment(): void {
+        this.value = this.value + 1;
+    }
+}
+
+const c = new Counter();
+c.increment();
+c.increment();
+c.increment();
+assert(c.value == 3, "class-at-root");
+
+print("done.");

tslang/test/tester/tests/00toplevel_no_main_with_helpers.ts

@@ -0,0 +1,31 @@
+// Root-level executable code coexisting with ordinary function/class
+// declarations, still with no explicit `function main()` anywhere - only the
+// root-level STATEMENTS (not the helper declarations) become the synthesized
+// `main` body (generateGlobalEntryCode in MLIRGenModule.cpp); the helpers stay
+// ordinary top-level declarations, callable from that synthesized body exactly
+// like they'd be callable from a hand-written main().
+
+function double(x: number): number {
+    return x * 2;
+}
+
+class Box {
+    value: number;
+    constructor(v: number) {
+        this.value = v;
+    }
+    get(): number {
+        return this.value;
+    }
+}
+
+const results: number[] = [];
+for (let i = 1; i <= 3; i++) {
+    results.push(double(i));
+}
+assert(results[0] == 2 && results[1] == 4 && results[2] == 6, "helpers-from-root");
+
+const box = new Box(21);
+assert(double(box.get()) == 42, "class-and-function-mixed");
+
+print("done.");