Timeout handling limits in Vala async methods: cooperative cancellation cannot interrupt synchronous sections

Direct answer

Vala’s async/await translation does not provide a language‑level hard timeout that can pre‑empt a long running synchronous section. Cancellation is observed only at yield points (await statements). If your async method contains a tight loop or CPU‑bound computation without an await, firing a GCancellable timeout will set the flag but the method will not react until it reaches the next yield point.

Confirmed facts

• The generated async code checks cancellable.is_cancelled() (via cancellable.check()) only when control returns to the GLib main loop at an await.
• Hierarchical or child GCancellable objects merely propagate the same flag; they do not introduce preemption.
• There is no compiler attribute, annotation, or GLib API that automatically injects cancellation checks into arbitrary synchronous code.

Steps to enforce timely cancellation

1. Insert explicit checks inside the synchronous work:

   async void long_work (GCancellable cancellable) throws Error {
       for (int i = 0; i < huge_limit; i++) {
           // … do a bit of work …
           if (i % 1024 == 0) {
               cancellable.check (); // throws if cancelled
           }
       }
   }

2. Break the work into yieldable chunks** using idle or timeout sources:

   async void chunked_work (GCancellable cancellable) throws Error {
       int i = 0;
       while (i < huge_limit) {
           // process a small batch
           for (int j = 0; j < BATCH_SIZE && i < huge_limit; j++, i++) {
               // … unit of work …
           }
           // yield control back to the main loop
           await GLib.idle_add (() => {
               return GLib.SOURCE_REMOVE; // continue later
           });
           cancellable.check (); // optional, but safe
       }
   }

3. Use a wrapper that creates a timeout source** and cancels the GCancellable after the desired interval:

   void run_with_timeout () {
       var cancellable = new GCancellable ();
       GLib.timeout_add_seconds (5, () => {
           cancellable.cancel ();
           return GLib.SOURCE_REMOVE;
       });
       try {
           await long_work (cancellable);
           stdout.printf ("Completed\n");
       } catch (IOErrorCancelled e) {
           stderr.printf ("Operation cancelled\n");
       }
   }

What to verify

Compile with valac --pkg gio-2.0 --pkg glib-2.0 your_file.vala and run inside a GLib.MainLoop. Observe that without the explicit check() or yielding chunks the method runs to completion despite the timeout firing.

Missing diagnostic detail

If the synchronous section performs I/O that could block the thread, let me know whether you are using a thread‑pool or the main thread, as that influences whether a GLib.Thread approach might be preferable.