007 chain second err leaks first resource

○ Planned This feature is planned but not yet implemented.

OWED hole: a second |err in a chain that leaks the first opened resource is refused.

Failure Output

Showing last 10 of 11 lines

  --> /Users/larsde/src/koru/tests/regression/300_ADVANCED_FEATURES/335_OBLIGATION_STRESS/335_007_chain_second_err_leaks_first_resource/db.kz:20:1
    |
 20 | ~pub tor connect { url: string }
    | ^

error[PARSE003]: single continuation branch 'started' carrying a payload is a one-variant tag union — declare the single output as a bare return instead: `-> *Transaction`
  --> /Users/larsde/src/koru/tests/regression/300_ADVANCED_FEATURES/335_OBLIGATION_STRESS/335_007_chain_second_err_leaks_first_resource/db.kz:34:1
    |
 34 | ~pub tor query { conn: *Connection<connected>, sql: string }
    | ^

Code

// PIN: mid-chain error path leaks the connection.
//
// connect() opens *Connection<connected!>. query() READS the connection
// (conn: *Connection<connected> — no consume marker) and can return | err.
// On the | err path, the connection is still alive with connected! obligation
// but the handler drops to _ without calling disconnect().
//
// Legal form (both paths discharge): 330_027_db_transaction_pattern/input.kz:4-8
//   Both | then and | else call disconnect(conn: c).
//
// Rust analogy: Acquiring a resource, calling a fallible operation that borrows
// it, and returning early via `?` — the resource is leaked because no RAII
// destructor fires and no manual drop is in scope.
//
// Grounding:
//   connect event + connected! obligation: 330_027_db_transaction_pattern/db.kz:20-29
//   query reads (non-consuming) connection: 330_027_db_transaction_pattern/db.kz:34-43
//   disconnect consumes connected!: 330_027_db_transaction_pattern/db.kz:62-64
//   chain structure: 330_027_db_transaction_pattern/input.kz:4-8
//   | err _ |> _ branch syntax: 330_061_inline_obligation_cascade/input.kz:81
~import app/db
~app/db:connect(url: "postgres://localhost/test")
| connected c |> app/db:query(conn: c, sql: "SELECT 1")
    | started tx |> app/db:rollback(tx) |> app/db:disconnect(conn: c)
    | err _ |> _

input.kz

Supporting Files

// Library module: db
// Database operations with layered cleanup obligations
//
// Pattern: connect → query → (commit OR rollback) → disconnect
// Two obligations:
//   1. connected! on Connection - must call disconnect
//   2. transaction! on Transaction - must call commit or rollback

const std = @import("std");

const Connection = struct {
    id: i32,
};

const Transaction = struct {
    conn: *Connection,
};

// Connect to database - creates connected! obligation
~pub tor connect { url: string }
| connected *Connection<connected!>

~proc connect|zig {
    std.debug.print("Connecting to: {s}\n", .{url});
    const allocator = std.heap.page_allocator;
    const c = allocator.create(Connection) catch unreachable;
    c.* = Connection{ .id = 1 };
    return .{ .connected = c };
}

// Start a query/transaction - creates transaction! obligation
// The connection must be in [connected] state (required, but not consumed)
// The connected! obligation is tracked separately and discharged by disconnect()
~pub tor query { conn: *Connection<connected>, sql: string }
| started *Transaction<transaction!>

~proc query|zig {
    std.debug.print("Query: {s}\n", .{sql});
    const allocator = std.heap.page_allocator;
    const t = allocator.create(Transaction) catch unreachable;
    t.* = Transaction{ .conn = conn };
    return .{ .started = t };
}

// Commit - CONSUMES transaction! obligation
~pub tor commit { tx: *Transaction<!transaction> }

~proc commit|zig {
    std.debug.print("Committing transaction\n", .{});
}

// Rollback - CONSUMES transaction! obligation (alternative to commit)
~pub tor rollback { tx: *Transaction<!transaction> }

~proc rollback|zig {
    std.debug.print("Rolling back transaction\n", .{});
}

// Disconnect - CONSUMES connected! obligation
~pub tor disconnect { conn: *Connection<!connected> }

~proc disconnect|zig {
    std.debug.print("Disconnecting\n", .{});
}

db.kz

Actual compiler output

error[PARSE003]: single continuation branch 'connected' carrying a payload is a one-variant tag union — declare the single output as a bare return instead: `-> *Connection`
  --> /Users/larsde/src/koru/tests/regression/300_ADVANCED_FEATURES/335_OBLIGATION_STRESS/335_007_chain_second_err_leaks_first_resource/db.kz:20:1
    |
 20 | ~pub tor connect { url: string }
    | ^

error[PARSE003]: single continuation branch 'started' carrying a payload is a one-variant tag union — declare the single output as a bare return instead: `-> *Transaction`
  --> /Users/larsde/src/koru/tests/regression/300_ADVANCED_FEATURES/335_OBLIGATION_STRESS/335_007_chain_second_err_leaks_first_resource/db.kz:34:1
    |
 34 | ~pub tor query { conn: *Connection<connected>, sql: string }
    | ^

Must contain:

was not discharged

Flows

flow ~connect click a branch to expand · @labels scroll to their anchor

connect (url: "postgres://localhost/test")

Test Configuration

MUST_ERROR

← 006 err branch leaks opened resource 020 instance single discharger →