09 empty transaction

✓ Passing This code compiles and runs correctly.

Code

// TEST: Try to commit a transaction without executing anything
//
// begin() produces Transaction[started!]
// commit() requires Transaction[!active]
// These states don't match! You can't commit an empty transaction.
//
// This prevents wasteful "BEGIN; COMMIT;" patterns.
// If you start a transaction, you MUST do something with it.
//
// EXPECTED: Compiler error - type mismatch (started vs active)

~import app/db

~app/db:connect(host: "localhost")
| ok c |> app/db:begin(conn: c)
    | ok t |> app/db:commit(tx: t)
        | ok conn |> app/db:close(conn)
            | err _ |> _
        | err _ |> _
    | err _ |> _
| err _ |> _

input.kz

Must contain:

Phantom state mismatch

Error Verification

Expected Error Pattern

state mismatch

Actual Compiler Output ✓ Pattern matched

error[KORU030]: Phantom state mismatch: expected 'app.db:active' but got 'app.db:started!' for argument 'tx'
  --> phantom_semantic_check:15:0

error[KORU030]: Resource 't' <started!> was not discharged. Call: app.db:exec
  --> phantom_semantic_check:15:0

❌ Compiler coordination error: Phantom semantic validation failed
error: CompilerCoordinationFailed
/Users/larsde/src/koru/tests/regression/900_EXAMPLES_SHOWCASE/910_LANGUAGE_SHOOTOUT/2104_09_empty_transaction/backend.zig:94:13: 0x100b3f38b in emit (backend)
            return error.CompilerCoordinationFailed;
            ^
/Users/larsde/src/koru/tests/regression/900_EXAMPLES_SHOWCASE/910_LANGUAGE_SHOOTOUT/2104_09_empty_transaction/backend.zig:190:28: 0x100b40077 in main (backend)
    const generated_code = try RuntimeEmitter.emit(compile_allocator, final_ast);
                           ^

Imported Files

// Database module demonstrating phantom obligation semantics
//
// State machine:
//   connect()  → Connection[connected!]      -- must use connection
//   begin()    → Transaction[started!]       -- consumes conn, must exec
//   exec()     → Transaction[active!]        -- now can commit/rollback
//   commit()   → Connection[active!]         -- returns conn, can reuse or close
//   rollback() → Connection[active!]         -- returns conn, can reuse or close
//   close()    → void                        -- only accepts [!active], not [!connected]
//
// Key insight: close() requires [!active], which only comes from commit/rollback.
// This FORCES you to use the connection meaningfully before closing.

const std = @import("std");

const Connection = struct { handle: i32 };
const Transaction = struct { conn_handle: i32 };

// connect: creates connection with [connected!] obligation
~pub event connect { host: []const u8 }
| ok *Connection<connected!>
| err []const u8

~proc connect|zig {
    const c = std.heap.page_allocator.create(Connection) catch unreachable;
    c.* = Connection{ .handle = 42 };
    return .{ .ok = c };
}

// begin: consumes [!connected] OR [!active], produces Transaction[started!]
~pub event begin { conn: *Connection<!connected|!active> }
| ok *Transaction<started!>
| err []const u8

~proc begin|zig {
    const tx = std.heap.page_allocator.create(Transaction) catch unreachable;
    tx.* = Transaction{ .conn_handle = conn.handle };
    return .{ .ok = tx };
}

// exec: consumes [!started] OR [!active], produces Transaction[active!]
~pub event exec { tx: *Transaction<!started|!active>, sql: []const u8 }
| ok *Transaction<active!>
| err []const u8

~proc exec|zig {
    std.debug.print("Executing: {s}\n", .{sql});
    return .{ .ok = tx };
}

// commit: consumes [!active], returns Connection[active!]
~pub event commit { tx: *Transaction<!active> }
| ok *Connection<active!>
| err []const u8

~proc commit|zig {
    std.debug.print("COMMIT\n", .{});
    const c = std.heap.page_allocator.create(Connection) catch unreachable;
    c.* = Connection{ .handle = tx.conn_handle };
    std.heap.page_allocator.destroy(tx);
    return .{ .ok = c };
}

// rollback: consumes [!active], returns Connection[active!]
~pub event rollback { tx: *Transaction<!active> }
| ok *Connection<active!>
| err []const u8

~proc rollback|zig {
    std.debug.print("ROLLBACK\n", .{});
    const c = std.heap.page_allocator.create(Connection) catch unreachable;
    c.* = Connection{ .handle = tx.conn_handle };
    std.heap.page_allocator.destroy(tx);
    return .{ .ok = c };
}

// close: ONLY accepts [!active] - forces meaningful use before close
~pub event close { conn: *Connection<!active> }
| err []const u8

~proc close|zig {
    std.debug.print("Connection closed\n", .{});
    std.heap.page_allocator.destroy(conn);
}

db.kz

Test Configuration

MUST_FAIL

← 08 close without transaction 10 wrong base type →