diff --git a/src/diag.rs b/src/diag.rs
index d84331410..c31bffdee 100644
--- a/src/diag.rs
+++ b/src/diag.rs
@@ -83,8 +83,8 @@ impl Display for Level {
 /// # use typst::error;
 /// # use typst::syntax::Span;
 /// # let span = Span::ZERO;
-/// # let name = "";
-/// let error = error!(span, "there is an error with {}", name);
+/// # let thing = "";
+/// let error = error!(span, "there is an error with {}", thing);
 /// ```
 #[macro_export]
 macro_rules! error {
@@ -99,8 +99,7 @@ macro_rules! error {
 
 /// Construct a diagnostic with [`Warning`](Level::Warning) level.
 ///
-/// This works exactly like `error!`. See its documentation for more
-/// information.
+/// This works exactly like [`error!`].
 #[macro_export]
 macro_rules! warning {
     ($span:expr, $($tts:tt)*) => {
diff --git a/src/eval/capture.rs b/src/eval/capture.rs
index 05760594f..182468f7e 100644
--- a/src/eval/capture.rs
+++ b/src/eval/capture.rs
@@ -32,7 +32,7 @@ impl<'ast> Visit<'ast> for CapturesVisitor<'_> {
         match node {
             Expr::Ident(ident) => {
                 // Find out whether the identifier is not locally defined, but
-                // captured, and if so, replace it with its value.
+                // captured, and if so, capture its value.
                 if self.internal.get(ident).is_none() {
                     if let Some(slot) = self.external.get(ident) {
                         self.captures.def_slot(ident.as_str(), Rc::clone(slot));
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 176201619..524ef43a8 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -32,9 +32,9 @@ pub fn eval(env: &mut Env, tree: &Tree, scope: &Scope) -> Pass<ExprMap> {
 
 /// A map from expressions to the values they evaluated to.
 ///
-/// The raw pointers point into the expressions contained in some [tree](Tree).
+/// The raw pointers point into the expressions contained in some [`Tree`].
 /// Since the lifetime is erased, the tree could go out of scope while the hash
-/// map still lives. Though this could lead to lookup panics, it is not unsafe
+/// map still lives. Although this could lead to lookup panics, it is not unsafe
 /// since the pointers are never dereferenced.
 pub type ExprMap = HashMap<*const Expr, Value>;
 
@@ -84,8 +84,8 @@ impl Eval for Tree {
         }
 
         impl<'ast> Visit<'ast> for ExprVisitor<'_, '_> {
-            fn visit_expr(&mut self, item: &'ast Expr) {
-                self.map.insert(item as *const _, item.eval(self.ctx));
+            fn visit_expr(&mut self, node: &'ast Expr) {
+                self.map.insert(node as *const _, node.eval(self.ctx));
             }
         }
 
@@ -443,8 +443,8 @@ impl Eval for ExprIf {
         if let Value::Bool(condition) = condition {
             if condition {
                 self.if_body.eval(ctx)
-            } else if let Some(expr) = &self.else_body {
-                expr.eval(ctx)
+            } else if let Some(else_body) = &self.else_body {
+                else_body.eval(ctx)
             } else {
                 Value::None
             }
diff --git a/src/eval/scope.rs b/src/eval/scope.rs
index c0926c0cc..69d519fdf 100644
--- a/src/eval/scope.rs
+++ b/src/eval/scope.rs
@@ -52,16 +52,21 @@ impl<'a> Scopes<'a> {
         self.top = self.scopes.pop().expect("no pushed scope");
     }
 
-    /// Define a constant variable in the active scope.
+    /// Define a constant variable with a value in the active scope.
     pub fn def_const(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.top.def_const(var, value);
     }
 
-    /// Define a mutable variable in the active scope.
+    /// Define a mutable variable with a value in the active scope.
     pub fn def_mut(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.top.def_mut(var, value);
     }
 
+    /// Define a variable with a slot in the active scope.
+    pub fn def_slot(&mut self, var: impl Into<String>, slot: Slot) {
+        self.top.def_slot(var, slot);
+    }
+
     /// Look up the slot of a variable.
     pub fn get(&self, var: &str) -> Option<&Slot> {
         iter::once(&self.top)
@@ -84,7 +89,7 @@ impl Scope {
         Self::default()
     }
 
-    /// Define a constant variable.
+    /// Define a constant variable with a value.
     pub fn def_const(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         let cell = RefCell::new(value.into());
 
@@ -95,7 +100,7 @@ impl Scope {
         self.values.insert(var.into(), Rc::new(cell));
     }
 
-    /// Define a mutable variable.
+    /// Define a mutable variable with a value.
     pub fn def_mut(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.values.insert(var.into(), Rc::new(RefCell::new(value.into())));
     }
diff --git a/src/exec/context.rs b/src/exec/context.rs
index 62f508802..b37b15cb2 100644
--- a/src/exec/context.rs
+++ b/src/exec/context.rs
@@ -178,8 +178,8 @@ impl<'a> ExecContext<'a> {
 
     /// Start a layouting group.
     ///
-    /// All further calls to [`push`](Self::push) will collect nodes for this group.
-    /// The given metadata will be returned alongside the collected nodes
+    /// All further calls to [`push`](Self::push) will collect nodes for this
+    /// group. The given metadata will be returned alongside the collected nodes
     /// in a matching call to [`end_group`](Self::end_group).
     fn start_group<T: 'static>(&mut self, meta: T) {
         self.groups.push((Box::new(meta), std::mem::take(&mut self.inner)));
diff --git a/src/exec/state.rs b/src/exec/state.rs
index 756a485c0..22839c54d 100644
--- a/src/exec/state.rs
+++ b/src/exec/state.rs
@@ -133,7 +133,7 @@ impl FontState {
 impl Default for FontState {
     fn default() -> Self {
         Self {
-            /// The default tree of font fallbacks.
+            // The default tree of font fallbacks.
             families: Rc::new(fallback! {
                 list: [],
                 classes: { "monospace"  => ["inconsolata"] },