Apply suggestions from code review

Co-authored-by: Mazdak Farrokhzad <twingoow@gmail.com>
Signed-off-by: Noa <coolreader18@gmail.com>

Author: coolreader18

crates/core/src/host/v8/string.rs

@@ -37,6 +37,7 @@ impl StringConst {
             .expect("`create_external_onebyte_const` should've asserted `.len() < kMaxLength`")
     }
 
+    /// Returns the backing string slice.
     pub(super) fn as_str(&'static self) -> &'static str {
         self.0.as_str()
     }

crates/core/src/host/v8/syscall/hooks.rs

@@ -12,16 +12,19 @@ use crate::host::v8::error::TypeError;
 use crate::host::v8::from_value::cast;
 use crate::host::v8::string::StringConst;
 
-pub(super) fn get_hook_function<'s>(
-    scope: &mut PinScope<'s, '_>,
+/// Returns the hook function `name` on `hooks_obj`.
+pub(super) fn get_hook_function<'scope>(
+    scope: &mut PinScope<'scope, '_>,
     hooks_obj: Local<'_, Object>,
     name: &'static StringConst,
-) -> ExcResult<Local<'s, Function>> {
+) -> ExcResult<Local<'scope, Function>> {
     let key = name.string(scope);
     let object = property(scope, hooks_obj, key)?;
     cast!(scope, object, Function, "module function hook `{}`", name.as_str()).map_err(|e| e.throw(scope))
 }
 
+/// Registers all the module function `hooks`
+/// and sets the given `AbiVersion` to `abi`.
 pub(super) fn set_hook_slots(
     scope: &mut PinScope<'_, '_>,
     abi: AbiVersion,
@@ -34,7 +37,7 @@ pub(super) fn set_hook_slots(
     for &(hook, func) in hooks {
         hooks_info
             .register(hook, abi)
-            .map_err(|_| TypeError("cannot call register_hooks multiple times").throw(scope))?;
+            .map_err(|_| TypeError("cannot call `register_hooks` multiple times").throw(scope))?;
         ctx.set_embedder_data(hook.to_slot_index(), func.into());
     }
     Ok(())
@@ -47,7 +50,8 @@ pub(in crate::host::v8) enum ModuleHook {
 }
 
 impl ModuleHook {
-    /// Get the `v8::Context::{get,set}_embedder_data` slot that holds this hook.
+    /// Returns the index for the slot that holds the module function hook.
+    /// The index is passed to `v8::Context::{get,set}_embedder_data`.
     fn to_slot_index(self) -> i32 {
         match self {
             ModuleHook::DescribeModule => 20,
@@ -56,13 +60,17 @@ impl ModuleHook {
     }
 }
 
+/// Holds the `AbiVersion` used by the module
+/// and the module hooks registered by the module
+/// for that version.
 #[derive(Default)]
 struct HooksInfo {
     abi: OnceCell<AbiVersion>,
     registered: EnumMap<ModuleHook, OnceCell<()>>,
 }
 
 impl HooksInfo {
+    /// Returns, and possibly creates, the [`HooksInfo`] stored in `ctx`.
     fn get_or_create(ctx: &Context) -> Rc<Self> {
         ctx.get_slot().unwrap_or_else(|| {
             let this = Rc::<Self>::default();
@@ -78,16 +86,18 @@ impl HooksInfo {
         self.registered[hook].set(())
     }
 
+    /// Returns the `AbiVersion` for the given `hook`, if any.
     fn get(&self, hook: ModuleHook) -> Option<AbiVersion> {
         self.registered[hook].get().and(self.abi.get().copied())
     }
 }
 
 #[derive(Copy, Clone)]
-pub(in crate::host::v8) struct HookFunction<'s>(pub AbiVersion, pub Local<'s, Function>);
+/// The actual callable module hook function and its abi version.
+pub(in super::super) struct HookFunction<'scope>(pub AbiVersion, pub Local<'scope, Function>);
 
 /// Returns the hook function previously registered in [`register_hooks`].
-pub(in crate::host::v8) fn get_hook<'scope>(
+pub(in super::super) fn get_hook<'scope>(
     scope: &mut PinScope<'scope, '_>,
     hook: ModuleHook,
 ) -> Option<HookFunction<'scope>> {

crates/core/src/host/v8/syscall/mod.rs

@@ -23,20 +23,20 @@ pub enum AbiVersion {
 
 /// A dependency resolver for the user's module
 /// that will resolve `spacetimedb_sys` to a module that exposes the ABI.
-pub(super) fn resolve_sys_module<'s>(
-    context: Local<'s, Context>,
-    spec: Local<'s, v8::String>,
-    _attrs: Local<'s, FixedArray>,
-    _referrer: Local<'s, Module>,
-) -> Option<Local<'s, Module>> {
+pub(super) fn resolve_sys_module<'scope>(
+    context: Local<'scope, Context>,
+    spec: Local<'scope, v8::String>,
+    _attrs: Local<'scope, FixedArray>,
+    _referrer: Local<'scope, Module>,
+) -> Option<Local<'scope, Module>> {
     callback_scope!(unsafe scope, context);
     resolve_sys_module_inner(scope, spec).ok()
 }
 
-fn resolve_sys_module_inner<'s>(
-    scope: &mut PinScope<'s, '_>,
-    spec: Local<'s, v8::String>,
-) -> ExcResult<Local<'s, Module>> {
+fn resolve_sys_module_inner<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    spec: Local<'scope, v8::String>,
+) -> ExcResult<Local<'scope, Module>> {
     let scratch = &mut scratch_buf::<32>();
     let spec = spec.to_rust_cow_lossy(scope, scratch);
 
@@ -65,6 +65,9 @@ fn resolve_sys_module_inner<'s>(
     }
 }
 
+/// Calls the registered `__call_reducer__` function hook.
+///
+/// This handles any (future) ABI version differences.
 pub(super) fn call_call_reducer(
     scope: &mut PinScope<'_, '_>,
     fun: HookFunction<'_>,
@@ -77,6 +80,8 @@ pub(super) fn call_call_reducer(
 }
 
 /// Calls the registered `__describe_module__` function hook.
+///
+/// This handles any (future) ABI version differences.
 pub(super) fn call_describe_module<'scope>(
     scope: &mut PinScope<'scope, '_>,
     fun: HookFunction<'_>,