Use global refs for nil and t, to avoid repeated intern calls

Author: ubolonton

Cargo.toml

@@ -27,6 +27,7 @@ failure = { version = "0.1.5", features = ["std"] }
 failure_derive = "0.1.5"
 lazy_static = "1.4"
 ctor = "0.1.12"
+once_cell = "1.2.0"
 emacs_module = { path = "emacs-module", version = "0.12.0" }
 emacs-macros = { path = "emacs-macros", version = "0.12.0" }
 

src/call.rs

@@ -121,6 +121,6 @@ impl<'e, T: AsRef<str>> IntoLispCallable<'e> for T {
 impl<'e> IntoLispCallable<'e> for &'e GlobalRef {
     #[inline(always)]
     fn into_lisp_callable(self, env: &'e Env) -> Result<Value<'e>> {
-        self.within(env).into_lisp_callable(env)
+        self.bind(env).into_lisp_callable(env)
     }
 }

src/init.rs

@@ -63,6 +63,7 @@ type InitFn = dyn Fn(&Env) -> Result<()> + Send + 'static;
 
 type FnMap = HashMap<String, Box<InitFn>>;
 
+// TODO: Use once_cell instead of lazy_static
 // TODO: How about defining these in user crate, and requiring #[module] to be at the crate's root?
 // TODO: We probably don't need the mutexes.
 lazy_static! {

src/lib.rs

@@ -54,6 +54,7 @@ mod value;
 mod types;
 mod error;
 mod call;
+mod symbol;
 
 /// This exposes some raw types for module to use (e.g. in `emacs_module_init`) without having to
 /// declare the raw `emacs_module` as a dependency.

src/symbol.rs

@@ -0,0 +1,33 @@
+#![allow(non_upper_case_globals)]
+
+use crate::{Result, Env, types::OnceGlobalRef, init::__INIT_FNS__};
+use ctor::ctor;
+
+macro_rules! decl {
+    ($($name:ident)*) => {
+        $(pub static $name: OnceGlobalRef = OnceGlobalRef::new();)*
+    }
+}
+
+decl! {
+    nil t
+}
+
+fn initialize(env: &Env) -> Result<()> {
+    macro_rules! init {
+        ($($name:ident)*) => {
+            $(OnceGlobalRef::init_to_symbol(&$name, env, stringify!($name))?;)*
+        };
+    }
+    init! {
+        nil t
+    }
+    Ok(())
+}
+
+#[ctor]
+fn register_initializer() {
+    __INIT_FNS__.lock().expect("Failed to acquire a write lock on map of initializers")
+        // XXX: In theory, this can conflict with a user-defined function name.
+        .insert("__emacs_module_rs_initialize_symbols_ ".into(), Box::new(initialize));
+}

src/types/global.rs

@@ -1,3 +1,7 @@
+use std::ops::Deref;
+
+use once_cell::sync::OnceCell;
+
 use emacs_module::emacs_value;
 
 use super::*;
@@ -51,7 +55,7 @@ impl GlobalRef {
     /// [`Env`]: struct.Env.html
     /// [`Value`]: struct.Value.html
     #[inline]
-    pub fn within<'e>(&'e self, env: &'e Env) -> Value<'e> {
+    pub fn bind<'e, 'g: 'e>(&'g self, env: &'e Env) -> Value<'e> {
         unsafe { Value::new(self.raw, env) }
     }
 
@@ -75,7 +79,7 @@ impl<'e> FromLisp<'e> for GlobalRef {
 impl<'e> IntoLisp<'e> for &'e GlobalRef {
     #[inline(always)]
     fn into_lisp(self, env: &'e Env) -> Result<Value<'e>> {
-        Ok(self.within(env))
+        Ok(self.bind(env))
     }
 }
 
@@ -88,3 +92,42 @@ impl<'e> Value<'e> {
         GlobalRef::new(self)
     }
 }
+
+/// A [`GlobalRef`] that can be initialized once. This is useful for long-lived values that should
+/// be initialized when the module is loaded, such as frequently-used symbols.
+///
+/// [`GlobalRef`]: struct.GlobalRef.html
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct OnceGlobalRef {
+    inner: OnceCell<GlobalRef>
+}
+
+impl OnceGlobalRef {
+    pub(crate) const fn new() -> Self {
+        Self { inner: OnceCell::new() }
+    }
+
+    /// Initializes this global reference with the given function.
+    #[doc(hidden)]
+    pub fn init<F: FnOnce(&Env) -> Result<Value>>(&self, env: &Env, f: F) -> Result<()> {
+        let g = f(env)?.make_global_ref();
+        self.inner.set(g).expect("Cannot initialize a global reference more than once");
+        Ok(())
+    }
+
+    /// Points this global reference to an interned Lisp symbol with the given name.
+    #[doc(hidden)]
+    pub fn init_to_symbol(&self, env: &Env, name: &str) -> Result<()> {
+        self.init(env, |env| env.intern(name))
+    }
+}
+
+impl Deref for OnceGlobalRef {
+    type Target = GlobalRef;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.inner.get().expect("Cannot access an uninitialized global reference")
+    }
+}

src/types/mod.rs

@@ -1,6 +1,6 @@
-use crate::{Env, Value, Result};
+use crate::{symbol, Env, Value, Result};
 
-pub use {user_ptr::Transfer, vector::Vector, global::GlobalRef};
+pub use {user_ptr::Transfer, vector::Vector, global::{GlobalRef, OnceGlobalRef}};
 
 mod integer;
 mod float;
@@ -64,23 +64,23 @@ impl<'e, T: IntoLisp<'e>> IntoLisp<'e> for Option<T> {
     fn into_lisp(self, env: &'e Env) -> Result<Value<'_>> {
         match self {
             Some(t) => t.into_lisp(env),
-            None => env.intern("nil"),
+            None => symbol::nil.into_lisp(env),
         }
     }
 }
 
 impl IntoLisp<'_> for () {
     fn into_lisp(self, env: &Env) -> Result<Value<'_>> {
-        env.intern("nil")
+        symbol::nil.into_lisp(env)
     }
 }
 
 impl IntoLisp<'_> for bool {
     fn into_lisp(self, env: &Env) -> Result<Value<'_>> {
         if self {
-            env.intern("t")
+            symbol::t.into_lisp(env)
         } else {
-            env.intern("nil")
+            symbol::nil.into_lisp(env)
         }
     }
 }

src/value.rs

@@ -23,7 +23,7 @@ impl<'e> Value<'e> {
     ///
     /// # Safety
     ///
-    /// The raw value must come from the given [`Env`].
+    /// The raw value must not live longer than the given [`Env`].
     ///
     /// [`Env`]: struct.Env.html
     #[doc(hidden)]