refactor(napi): rename NapiEnv lifetime to 'env

Author: aqrln

napi/src/value/any.rs

@@ -9,13 +9,13 @@ use super::{NapiArray, NapiBoolean, NapiNull, NapiNumber, NapiObject,
             NapiValueType};
 
 #[derive(Clone, Copy, Debug)]
-pub struct NapiAny<'a> {
+pub struct NapiAny<'env> {
     value: sys::napi_value,
-    env: &'a NapiEnv,
+    env: &'env NapiEnv,
 }
 
-impl<'a> NapiAny<'a> {
-    pub fn new(env: &'a NapiEnv) -> NapiResult<Self> {
+impl<'env> NapiAny<'env> {
+    pub fn new(env: &'env NapiEnv) -> NapiResult<Self> {
         let mut value = ptr::null_mut();
         env.handle_status(unsafe {
             sys::napi_get_undefined(env.as_sys_env(), &mut value)
@@ -24,11 +24,11 @@ impl<'a> NapiAny<'a> {
         Ok(Self { value, env })
     }
 
-    pub fn with_value(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+    pub fn with_value(env: &'env NapiEnv, value: sys::napi_value) -> Self {
         Self { env, value }
     }
 
-    pub fn as_undefined(&self) -> NapiResult<NapiUndefined<'a>> {
+    pub fn as_undefined(&self) -> NapiResult<NapiUndefined<'env>> {
         match self.value_type()? {
             NapiValueType::Undefined => {
                 Ok(NapiUndefined::construct(self.env(), self.as_sys_value()))
@@ -40,7 +40,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_null(&self) -> NapiResult<NapiNull<'a>> {
+    pub fn as_null(&self) -> NapiResult<NapiNull<'env>> {
         match self.value_type()? {
             NapiValueType::Null => {
                 Ok(NapiNull::construct(self.env(), self.as_sys_value()))
@@ -52,7 +52,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_boolean(&self) -> NapiResult<NapiBoolean<'a>> {
+    pub fn as_boolean(&self) -> NapiResult<NapiBoolean<'env>> {
         match self.value_type()? {
             NapiValueType::Boolean => {
                 Ok(NapiBoolean::construct(self.env(), self.as_sys_value()))
@@ -64,7 +64,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_number(&self) -> NapiResult<NapiNumber<'a>> {
+    pub fn as_number(&self) -> NapiResult<NapiNumber<'env>> {
         match self.value_type()? {
             NapiValueType::Number => {
                 Ok(NapiNumber::construct(self.env(), self.as_sys_value()))
@@ -76,7 +76,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_string(&self) -> NapiResult<NapiString<'a>> {
+    pub fn as_string(&self) -> NapiResult<NapiString<'env>> {
         match self.value_type()? {
             NapiValueType::String => {
                 Ok(NapiString::construct(self.env(), self.as_sys_value()))
@@ -88,7 +88,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_object(&self) -> NapiResult<NapiObject<'a>> {
+    pub fn as_object(&self) -> NapiResult<NapiObject<'env>> {
         match self.value_type()? {
             NapiValueType::Object |
             NapiValueType::String |
@@ -102,7 +102,7 @@ impl<'a> NapiAny<'a> {
         }
     }
 
-    pub fn as_array(&self) -> NapiResult<NapiArray<'a>> {
+    pub fn as_array(&self) -> NapiResult<NapiArray<'env>> {
         if self.is_array()? {
             Ok(NapiArray::construct(self.env(), self.as_sys_value()))
         } else {
@@ -114,12 +114,12 @@ impl<'a> NapiAny<'a> {
     }
 }
 
-impl<'a> NapiValue<'a> for NapiAny<'a> {
+impl<'env> NapiValue<'env> for NapiAny<'env> {
     fn as_sys_value(&self) -> sys::napi_value {
         self.value
     }
 
-    fn env(&self) -> &'a NapiEnv {
+    fn env(&self) -> &'env NapiEnv {
         self.env
     }
 }

napi/src/value/array.rs

@@ -7,13 +7,13 @@ use sys;
 use super::{AsNapiObject, NapiAny, NapiValue, NapiValueInternal};
 
 #[derive(Clone, Copy, Debug)]
-pub struct NapiArray<'a> {
+pub struct NapiArray<'env> {
     value: sys::napi_value,
-    env: &'a NapiEnv,
+    env: &'env NapiEnv,
 }
 
-impl<'a> NapiArray<'a> {
-    pub fn new(env: &'a NapiEnv) -> NapiResult<Self> {
+impl<'env> NapiArray<'env> {
+    pub fn new(env: &'env NapiEnv) -> NapiResult<Self> {
         let mut value = ptr::null_mut();
         env.handle_status(unsafe {
             sys::napi_create_array(env.as_sys_env(), &mut value)
@@ -22,7 +22,7 @@ impl<'a> NapiArray<'a> {
         Ok(Self { value, env })
     }
 
-    pub fn with_len(env: &'a NapiEnv, len: usize) -> NapiResult<Self> {
+    pub fn with_len(env: &'env NapiEnv, len: usize) -> NapiResult<Self> {
         let mut value = ptr::null_mut();
         env.handle_status(unsafe {
             sys::napi_create_array_with_length(
@@ -53,32 +53,32 @@ impl<'a> NapiArray<'a> {
         self.len().map(|l| l == 0)
     }
 
-    pub fn get(&self, index: u32) -> NapiResult<NapiAny<'a>> {
+    pub fn get(&self, index: u32) -> NapiResult<NapiAny<'env>> {
         self.as_napi_object().get_element(index)
     }
 
     pub fn set<T>(&self, index: u32, value: &T) -> NapiResult<()>
     where
-        T: NapiValue<'a>,
+        T: NapiValue<'env>,
     {
         self.as_napi_object().set_element(index, value)
     }
 }
 
-impl<'a> NapiValue<'a> for NapiArray<'a> {
+impl<'env> NapiValue<'env> for NapiArray<'env> {
     fn as_sys_value(&self) -> sys::napi_value {
         self.value
     }
 
-    fn env(&self) -> &'a NapiEnv {
+    fn env(&self) -> &'env NapiEnv {
         self.env
     }
 }
 
-impl<'a> NapiValueInternal<'a> for NapiArray<'a> {
-    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+impl<'env> NapiValueInternal<'env> for NapiArray<'env> {
+    fn construct(env: &'env NapiEnv, value: sys::napi_value) -> Self {
         Self { env, value }
     }
 }
 
-impl<'a> AsNapiObject<'a> for NapiArray<'a> {}
+impl<'env> AsNapiObject<'env> for NapiArray<'env> {}

napi/src/value/boolean.rs

@@ -7,13 +7,13 @@ use sys;
 use super::{NapiValue, NapiValueInternal};
 
 #[derive(Clone, Copy, Debug)]
-pub struct NapiBoolean<'a> {
+pub struct NapiBoolean<'env> {
     value: sys::napi_value,
-    env: &'a NapiEnv,
+    env: &'env NapiEnv,
 }
 
-impl<'a> NapiBoolean<'a> {
-    fn new(env: &'a NapiEnv, value: bool) -> NapiResult<Self> {
+impl<'env> NapiBoolean<'env> {
+    fn new(env: &'env NapiEnv, value: bool) -> NapiResult<Self> {
         let mut sys_value = ptr::null_mut();
         env.handle_status(unsafe {
             sys::napi_get_boolean(env.as_sys_env(), value, &mut sys_value)
@@ -25,11 +25,11 @@ impl<'a> NapiBoolean<'a> {
         })
     }
 
-    pub fn truth(env: &'a NapiEnv) -> NapiResult<Self> {
+    pub fn truth(env: &'env NapiEnv) -> NapiResult<Self> {
         NapiBoolean::new(env, true)
     }
 
-    pub fn lie(env: &'a NapiEnv) -> NapiResult<Self> {
+    pub fn lie(env: &'env NapiEnv) -> NapiResult<Self> {
         NapiBoolean::new(env, false)
     }
 
@@ -48,18 +48,18 @@ impl<'a> NapiBoolean<'a> {
     }
 }
 
-impl<'a> NapiValue<'a> for NapiBoolean<'a> {
+impl<'env> NapiValue<'env> for NapiBoolean<'env> {
     fn as_sys_value(&self) -> sys::napi_value {
         self.value
     }
 
-    fn env(&self) -> &'a NapiEnv {
+    fn env(&self) -> &'env NapiEnv {
         self.env
     }
 }
 
-impl<'a> NapiValueInternal<'a> for NapiBoolean<'a> {
-    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+impl<'env> NapiValueInternal<'env> for NapiBoolean<'env> {
+    fn construct(env: &'env NapiEnv, value: sys::napi_value) -> Self {
         Self { env, value }
     }
 }

napi/src/value/mod.rs

@@ -35,27 +35,27 @@ pub enum NapiValueType {
     External,
 }
 
-pub trait NapiValue<'a> {
+pub trait NapiValue<'env> {
     fn as_sys_value(&self) -> sys::napi_value;
-    fn env(&self) -> &'a NapiEnv;
+    fn env(&self) -> &'env NapiEnv;
 
-    fn to_napi_boolean(&self) -> NapiResult<NapiBoolean<'a>> {
+    fn to_napi_boolean(&self) -> NapiResult<NapiBoolean<'env>> {
         coerce(self, sys::napi_coerce_to_bool)
     }
 
-    fn to_napi_number(&self) -> NapiResult<NapiNumber<'a>> {
+    fn to_napi_number(&self) -> NapiResult<NapiNumber<'env>> {
         coerce(self, sys::napi_coerce_to_number)
     }
 
-    fn to_napi_object(&self) -> NapiResult<NapiObject<'a>> {
+    fn to_napi_object(&self) -> NapiResult<NapiObject<'env>> {
         coerce(self, sys::napi_coerce_to_object)
     }
 
-    fn to_napi_string(&self) -> NapiResult<NapiString<'a>> {
+    fn to_napi_string(&self) -> NapiResult<NapiString<'env>> {
         coerce(self, sys::napi_coerce_to_string)
     }
 
-    fn as_napi_any(&self) -> NapiAny<'a> {
+    fn as_napi_any(&self) -> NapiAny<'env> {
         NapiAny::with_value(self.env(), self.as_sys_value())
     }
 
@@ -122,7 +122,7 @@ pub trait NapiValue<'a> {
 
     fn strict_equals<T>(&self, other: &T) -> NapiResult<bool>
     where
-        T: NapiValue<'a> + ?Sized,
+        T: NapiValue<'env> + ?Sized,
     {
         let env = self.env();
         let mut result = false;
@@ -140,17 +140,17 @@ pub trait NapiValue<'a> {
     }
 }
 
-pub trait AsNapiObject<'a>: NapiValue<'a> {
-    fn as_napi_object(&self) -> NapiObject<'a> {
+pub trait AsNapiObject<'env>: NapiValue<'env> {
+    fn as_napi_object(&self) -> NapiObject<'env> {
         NapiObject::construct(self.env(), self.as_sys_value())
     }
 }
 
-trait NapiValueInternal<'a>: NapiValue<'a> {
-    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self;
+trait NapiValueInternal<'env>: NapiValue<'env> {
+    fn construct(env: &'env NapiEnv, value: sys::napi_value) -> Self;
 }
 
-fn coerce<'a, T, U>(
+fn coerce<'env, T, U>(
     value: &T,
     napi_fn: unsafe extern "C" fn(
         sys::napi_env,
@@ -159,8 +159,8 @@ fn coerce<'a, T, U>(
     ) -> sys::napi_status,
 ) -> NapiResult<U>
 where
-    T: NapiValue<'a> + ?Sized,
-    U: NapiValueInternal<'a>,
+    T: NapiValue<'env> + ?Sized,
+    U: NapiValueInternal<'env>,
 {
     let env = value.env();
     let mut coerced_value = ptr::null_mut();
@@ -172,13 +172,13 @@ where
     Ok(U::construct(env, coerced_value))
 }
 
-fn check_type<'a, T>(
+fn check_type<'env, T>(
     value: &T,
     napi_fn: unsafe extern "C" fn(sys::napi_env, sys::napi_value, *mut bool)
         -> sys::napi_status,
 ) -> NapiResult<bool>
 where
-    T: NapiValue<'a> + ?Sized,
+    T: NapiValue<'env> + ?Sized,
 {
     let env = value.env();
     let mut result = false;

napi/src/value/null.rs

@@ -7,13 +7,13 @@ use sys;
 use super::{NapiValue, NapiValueInternal};
 
 #[derive(Clone, Copy, Debug)]
-pub struct NapiNull<'a> {
+pub struct NapiNull<'env> {
     value: sys::napi_value,
-    env: &'a NapiEnv,
+    env: &'env NapiEnv,
 }
 
-impl<'a> NapiNull<'a> {
-    pub fn new(env: &'a NapiEnv) -> NapiResult<Self> {
+impl<'env> NapiNull<'env> {
+    pub fn new(env: &'env NapiEnv) -> NapiResult<Self> {
         let mut value = ptr::null_mut();
         env.handle_status(
             unsafe { sys::napi_get_null(env.as_sys_env(), &mut value) },
@@ -23,18 +23,18 @@ impl<'a> NapiNull<'a> {
     }
 }
 
-impl<'a> NapiValue<'a> for NapiNull<'a> {
+impl<'env> NapiValue<'env> for NapiNull<'env> {
     fn as_sys_value(&self) -> sys::napi_value {
         self.value
     }
 
-    fn env(&self) -> &'a NapiEnv {
+    fn env(&self) -> &'env NapiEnv {
         self.env
     }
 }
 
-impl<'a> NapiValueInternal<'a> for NapiNull<'a> {
-    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+impl<'env> NapiValueInternal<'env> for NapiNull<'env> {
+    fn construct(env: &'env NapiEnv, value: sys::napi_value) -> Self {
         Self { env, value }
     }
 }