Add unsafe_untracked_call to allow tracked code to call untracked functions

SKStore lazy mappers run in a tracked context, which prevents them from
calling untracked (side-effectful) functions. This is correct for most
cases, but some use cases—such as lazy file system access in mappers—
legitimately need to perform I/O during reactive computation, with the
caller taking responsibility for correctness and invalidation.

This adds:
- A new @allow_tracked_call annotation that exempts an untracked function
  from the "Cannot call an untracked function from a tracked context" error
- Unsafe.unsafe_untracked_call<T>, a generic function that takes an
  untracked lambda and calls it, usable from tracked contexts
- A typechecker test exercising the new functionality

The annotation check is implemented in tfun_call (skipTyping.sk) by
looking up the callee's annotations before invoking check_tracking.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mbouaziz

skiplang/compiler/src/skipTyping.sk

@@ -1882,7 +1882,17 @@ fun tfun_call(
   );
   args1 = TUtils.add_default_arguments(add_args, args);
   e = (pos, TAst.Call(f, args1));
-  check_tracking(pos, env, tracking);
+  allowTrackedCall = f.i1.i1 match {
+  | TAst.Fun(name, _) ->
+    SkipNaming.maybeGetFun(context, name.i1) match {
+    | Some(fd) -> annotationsContain(fd.annotations, "@allow_tracked_call", pos)
+    | None() -> false
+    }
+  | _ -> false
+  };
+  if (!allowTrackedCall) {
+    check_tracking(pos, env, tracking);
+  };
   (acc1, (return_ty, e))
 }
 

skiplang/compiler/tests/Typechecking/AllowTrackedCall.exp

@@ -0,0 +1 @@
+OK

skiplang/compiler/tests/Typechecking/AllowTrackedCall.sk

@@ -0,0 +1,17 @@
+module TypecheckingAllowTrackedCall;
+// @allow_tracked_call lets a tracked function call an untracked function
+
+untracked fun sideEffect(): String {
+  "OK"
+}
+
+// This function is tracked (default), but can call sideEffect()
+// via Unsafe.unsafe_untracked_call
+fun trackedCaller(): String {
+  Unsafe.unsafe_untracked_call(() -> sideEffect())
+}
+
+untracked fun main(): void {
+  print_raw(trackedCaller())
+}
+module end;

skiplang/prelude/src/core/Unsafe.sk

@@ -100,4 +100,13 @@ native fun array_set_byte<T>(v: mutable Array<T>, i: Int, b: UInt8): void;
 @cpp_extern
 native fun string_ptr(v: String, i: Int): Runtime.NonGCPointer;
 
+// Calls an untracked function from a tracked context.
+// Use this to perform side effects (e.g., file I/O) inside reactive
+// computations where you take responsibility for correctness and
+// invalidation.
+@allow_tracked_call
+untracked fun unsafe_untracked_call<T>(f: untracked () -> T): T {
+  f()
+}
+
 module end;