Use Typescript 5.2 Disposable for managing Guards

[nicoburniske]

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html

I could not get this to work. It kept throwing TypeError("Object not disposable."). I chose to implement a custom drop function on the guards instead, and have a try/finally helper to manage releasing the resources.

// @ts-ignore
Symbol.dispose ??= Symbol("Symbol.dispose");
// @ts-ignore
Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");

export class AtomicOperationGuard implements Disposable {
  constructor(private begin: OplogIndex) {}

  [Symbol.dispose]() {
    console.log("Disposing AtomicOperationGuard!!!")
    markEndOperation(this.begin);
  }
}

export function markAtomicOperation(): AtomicOperationGuard {
  const begin = markBeginOperation();
  return new AtomicOperationGuard(begin);
}

export function infallibleTransaction<Out>(f: (tx: InfallibleTransaction) => Out) : Out {
  using _atomic = markAtomicOperation();
  const beginOplogIndex = getOplogIndex();
  const tx = new InfallibleTransaction(beginOplogIndex);
  const result = f(tx);
  return result
}

This is the typescript compiler output

function infallibleTransaction(f) {
    const env_2 = { stack: [], error: void 0, hasError: false };
    try {
        const _atomic = __addDisposableResource(env_2, markAtomicOperation(), false);
        const beginOplogIndex = getOplogIndex();
        const tx = new InfallibleTransaction(beginOplogIndex);
        const result = f(tx);
        return result;
    }
    catch (e_2) {
        env_2.error = e_2;
        env_2.hasError = true;
    }
    finally {
        __disposeResources(env_2);
    }
}

function __addDisposableResource(env, value, async) {
    if (value !== null && value !== void 0) {
        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
        var dispose;
        if (async) {
            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
            dispose = value[Symbol.asyncDispose];
        }
        if (dispose === void 0) {
            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
            dispose = value[Symbol.dispose];
        }
        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
        env.stack.push({ value: value, dispose: dispose, async: async });
    }
    else if (async) {
        env.stack.push({ async: true });
    }
    return value;
}

var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
    var e = new Error(message);
    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};

function __disposeResources(env) {
    function fail(e) {
        env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
        env.hasError = true;
    }
    function next() {
        while (env.stack.length) {
            var rec = env.stack.pop();
            try {
                var result = rec.dispose && rec.dispose.call(rec.value);
                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
            }
            catch (e) {
                fail(e);
            }
        }
        if (env.hasError) throw env.error;
    }
    return next();
}