napi 3.12.0-alpha.0

N-API bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#![cfg(feature = "napi4")]

use napi::{
  bindgen_prelude::ThreadsafeFunctionBuilder,
  threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode},
  Error, Status,
};

struct BorrowedStatus<'a>(&'a str);

impl AsRef<str> for BorrowedStatus<'_> {
  fn as_ref(&self) -> &str {
    self.0
  }
}

impl From<Status> for BorrowedStatus<'_> {
  fn from(_status: Status) -> Self {
    Self("status")
  }
}

struct OwnedStatus(String);

impl AsRef<str> for OwnedStatus {
  fn as_ref(&self) -> &str {
    &self.0
  }
}

impl From<Status> for OwnedStatus {
  fn from(status: Status) -> Self {
    Self(status.as_ref().to_owned())
  }
}

type BaseBuilder<'env> = ThreadsafeFunctionBuilder<'env, (), (), (), Status, false, false, 0>;
type BorrowedBuilder<'env, 'status> =
  ThreadsafeFunctionBuilder<'env, (), (), (), BorrowedStatus<'status>, false, false, 0>;
type BorrowedFatalThreadsafeFunction<'status> =
  ThreadsafeFunction<(), (), (), BorrowedStatus<'status>, false, false, 0>;
type OwnedCalleeHandledThreadsafeFunction =
  ThreadsafeFunction<(), (), (), OwnedStatus, true, false, 0>;

#[test]
fn fatal_mode_preserves_borrowed_error_status_source_compatibility() {
  fn accept_borrowed_status<'status>(
    reason: &'status str,
    tsfn: Option<BorrowedFatalThreadsafeFunction<'status>>,
  ) {
    let _ = (reason, tsfn);
  }

  fn retag_builder<'env, 'status>(
    builder: BaseBuilder<'env>,
    reason: &'status str,
  ) -> BorrowedBuilder<'env, 'status> {
    let _ = reason;
    builder.error_status::<BorrowedStatus<'status>>()
  }

  let _: for<'status> fn(&'status str, Option<BorrowedFatalThreadsafeFunction<'status>>) =
    accept_borrowed_status;
  let _: for<'env, 'status> fn(BaseBuilder<'env>, &'status str) -> BorrowedBuilder<'env, 'status> =
    retag_builder;
}

#[test]
fn callee_handled_calls_accept_owned_send_static_error_statuses() {
  fn call_with_owned_error(tsfn: &OwnedCalleeHandledThreadsafeFunction) {
    let status = tsfn.call(
      Err(Error::new(
        OwnedStatus("CompileContract".to_owned()),
        "compile contract",
      )),
      ThreadsafeFunctionCallMode::NonBlocking,
    );
    let _: Status = status;
  }

  let _: fn(&OwnedCalleeHandledThreadsafeFunction) = call_with_owned_error;
}