Clean up

src/ast/eval.rs

@@ -112,7 +112,7 @@ impl Expression {
                 Self::Begin(body) => body.tail_eval(env, cont).await,
                 Self::Var(var) => Ok(ValuesOrPreparedCall::Values(vec![var
                     .fetch(env)
-                    .map_err(|ident| RuntimeError::undefined_variable(ident))?])),
+                    .map_err(RuntimeError::undefined_variable)?])),
             }
         })
     }
@@ -336,7 +336,7 @@ impl SyntaxCase {
         Expression::parse(transformed, &expansion_env, cont)
             .await
             .expect("fixme")
-            .eval(&env, cont)
+            .eval(env, cont)
             .await
     }
 }

src/ast/mod.rs

@@ -82,7 +82,7 @@ impl AstNode {
                 Ok(None)
             }
             Some([Syntax::Identifier { ident, span, .. }, ..]) if ident.name == "define-syntax" => {
-                return Err(parse::ParseAstError::BadForm(span.clone()));
+                Err(parse::ParseAstError::BadForm(span.clone()))
             }
             Some(syn @ [Syntax::Identifier { ident, span, .. }, ..]) if ident.name == "define" => {
                 Ok(Some(Self::Definition(

src/ast/parse.rs

@@ -82,7 +82,7 @@ impl Definition {
                                             second: span.clone(),
                                         });
                                     }
-                                    new_env.def_local_var(&ident, Gc::new(Value::Undefined));
+                                    new_env.def_local_var(ident, Gc::new(Value::Undefined));
                                     bound.insert(ident.clone(), span.clone());
                                     fixed.push(ident.clone());
                                 }
@@ -106,7 +106,7 @@ impl Definition {
                                         });
                                     }
                                     let remaining = ident.clone();
-                                    new_env.def_local_var(&ident, Gc::new(Value::Undefined));
+                                    new_env.def_local_var(ident, Gc::new(Value::Undefined));
                                     bound.insert(remaining.clone(), span.clone());
                                     Formals::VarArgs {
                                         fixed: fixed.into_iter().collect(),
@@ -214,7 +214,7 @@ where
     'a: 'b,
 {
     Box::pin(async move {
-        if body.len() == 0 {
+        if body.is_empty() {
             return Err(ParseAstError::EmptyBody(span.clone()));
         }
 
@@ -302,7 +302,7 @@ impl Expression {
         let FullyExpanded {
             expanded,
             expansion_ctxs: expansion_envs,
-        } = syn.expand(&env, cont).await?;
+        } = syn.expand(env, cont).await?;
         let expansion_env = env.push_expansion_env(expansion_envs);
         Self::parse_expanded(expanded, &expansion_env, cont).await
     }
@@ -403,7 +403,7 @@ impl Expression {
                     [Syntax::Identifier { ident, span, .. }, .., Syntax::Null { .. }]
                         if ident.name == "define" =>
                     {
-                        return Err(ParseAstError::DefInExprContext(span.clone()));
+                        Err(ParseAstError::DefInExprContext(span.clone()))
                     }
 
                     // Regular old function call:
@@ -413,7 +413,7 @@ impl Expression {
                             .map(Expression::Call)
                     }
 
-                    _ => return Err(ParseAstError::BadForm(span.clone())),
+                    _ => Err(ParseAstError::BadForm(span.clone())),
                 },
             }
         })
@@ -488,7 +488,7 @@ async fn parse_lambda(
                             second: span.clone(),
                         });
                     }
-                    new_contour.def_local_var(&ident, Gc::new(Value::Undefined));
+                    new_contour.def_local_var(ident, Gc::new(Value::Undefined));
                     bound.insert(ident.clone(), span.clone());
                     fixed.push(ident.clone());
                 }
@@ -508,7 +508,7 @@ async fn parse_lambda(
                         second: span.clone(),
                     });
                 }
-                new_contour.def_local_var(&ident, Gc::new(Value::Undefined));
+                new_contour.def_local_var(ident, Gc::new(Value::Undefined));
                 let remaining = ident.clone();
                 Formals::VarArgs {
                     fixed: fixed.into_iter().collect(),
@@ -727,7 +727,7 @@ impl Set {
 impl Quote {
     async fn parse(exprs: &[Syntax], span: &Span) -> Result<Self, ParseAstError> {
         match exprs {
-            [] => Err(dbg!(ParseAstError::ExpectedArgument(span.clone()))),
+            [] => Err(ParseAstError::ExpectedArgument(span.clone())),
             [Syntax::Null { .. }] => Ok(Quote { val: Value::Null }),
             [expr, Syntax::Null { .. }] => Ok(Quote {
                 val: Value::from_syntax(expr),

src/env.rs

@@ -70,8 +70,7 @@ impl Env {
             || {
                 self.up
                     .as_ref()
-                    .map(|up| up.read().fetch_var_ref(ident).map(VarRef::inc_depth))
-                    .flatten()
+                    .and_then(|up| up.read().fetch_var_ref(ident).map(VarRef::inc_depth))
             },
             |offset| Some(VarRef { depth: 0, offset }),
         )
@@ -286,9 +285,7 @@ impl GlobalRef {
         };
 
         let top = top.read();
-        let Some(var) = top.fetch_var_ref(&self.name) else {
-            return None;
-        };
+        let var = top.fetch_var_ref(&self.name)?;
         Some(top.fetch_var(var))
     }
 
@@ -377,15 +374,15 @@ impl ExpansionEnv<'_> {
         !matches!(self.fetch_var_ref(ident), Ref::Global(_))
     }
 
-    pub fn push_expansion_env<'a>(&'a self, ctxs: Vec<ExpansionCtx>) -> ExpansionEnv<'a> {
+    pub fn push_expansion_env(&self, ctxs: Vec<ExpansionCtx>) -> ExpansionEnv<'_> {
         ExpansionEnv {
             lexical_contour: self.lexical_contour.clone(),
             up: Some(self),
             expansion_ctxs: ctxs,
         }
     }
 
-    pub fn push_lexical_contour<'a>(&'a self, gc: Gc<Env>) -> ExpansionEnv<'a> {
+    pub fn push_lexical_contour(&self, gc: Gc<Env>) -> ExpansionEnv<'_> {
         ExpansionEnv {
             up: Some(self),
             expansion_ctxs: Vec::new(),

tests/r6rs.rs

@@ -1,14 +1,11 @@
 use std::sync::Arc;
 
 use scheme_rs::{
-    ast::AstNode,
     builtin,
     continuation::Continuation,
     env::Env,
     error::RuntimeError,
     gc::Gc,
-    lex::Token,
-    syntax::ParsedSyntax,
     value::{eqv, Value},
 };