Struct OwnerLock 

pub struct OwnerLock { /* private fields */ }

What: A held owner lock. Releasing it proves the lock still names this holder first. Dropping an unreleased lock releases it and ignores a failure. Why: An early return or an unwinding error must not leave a live-looking lock behind; an explicit release reports a changed owner.

In TS you’d write (pseudocode):

type OwnerLock = AsyncDisposable & { lockDirectory: string; token: string };

Implementations

impl OwnerLock

Accessors and release of a held lock.

pub fn inherited(directory: &Path, token: &str) -> OwnerLock

What: A view of a lock an ancestor process holds, which releases nothing. Why: An invocation nested under a landing-lock holder proves it with an inherited lease and proceeds under the ancestor’s lock instead of waiting for it (inheritedLandingLock in the incumbent).

In TS you’d write (pseudocode):

{ lockDirectory, token: process.env[LANDING_LEASE_ENV], [Symbol.asyncDispose]: async () => {} }

pub fn directory(&self) -> &Path

What: The published lock directory. Why: Leases and diagnostics name the lock.

In TS you’d write (pseudocode):

lock.lockDirectory

pub fn token(&self) -> &str

What: The token this holder published. Why: A lease proves which acquisition it belongs to.

In TS you’d write (pseudocode):

lock.token

pub fn release(self) -> Result<(), OwnerLockError>

What: Release the lock, failing when it no longer names this holder. mut self takes ownership: a released lock cannot be used again. Why: The release is the incumbent’s releaseHeldLock.

In TS you’d write (pseudocode):

await lock[Symbol.asyncDispose]();

Trait Implementations

impl Debug for OwnerLock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for OwnerLock

Dropping an unreleased lock releases it.

fn drop(&mut self)

What: Release the lock unless release already did; a failure is ignored. Why: Nothing can be reported from a drop, and a lock that changed owner is not this holder’s to remove.

In TS you’d write (pseudocode):

// `await using` disposal on an early exit.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.