diff --git a/src/api.rs b/src/api.rs
index c21117f..e987ffc 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -91,7 +91,7 @@ pub fn symbol_at(program: &SemanticProgram, file: FileId, offset: u32) -> Option
 /// All use sites of a symbol (span of each resolution reference).
 pub fn references(program: &SemanticProgram, symbol: SymbolId) -> Vec<Span> {
     let mut out = Vec::new();
-    for (_, res) in &program.resolution {
+    for res in program.resolution.values() {
         if let Resolution::Symbol(sid) = res {
             if *sid == symbol {
                 out.push(program.tables.symbol(*sid).span);
@@ -125,7 +125,7 @@ fn expr_node_at(
         walk_item_exprs(item, &mut |e: &crate::syntax::ast::Expr| {
             if e.span.contains(offset) {
                 let size = e.span.end - e.span.start;
-                if best.map_or(true, |(_, s)| size <= s) {
+                if best.is_none_or(|(_, s)| size <= s) {
                     best = Some((e.id, size));
                 }
             }
@@ -229,11 +229,8 @@ fn walk_stmt_exprs(s: &crate::syntax::ast::Stmt, f: &mut dyn FnMut(&crate::synta
                 }
             }
         }
-        K::Return { value } => {
-            if let Some(v) = value {
-                walk_expr_exprs(v, f);
-            }
-        }
+        K::Return { value: Some(v) } => walk_expr_exprs(v, f),
+        K::Return { value: None } => {}
         K::Expr(e) => walk_expr_exprs(e, f),
         K::Delete { target } => walk_expr_exprs(target, f),
         K::Hook { target, value } => {
diff --git a/src/compatibility.rs b/src/compatibility.rs
index 09d4a80..7a67a9b 100644
--- a/src/compatibility.rs
+++ b/src/compatibility.rs
@@ -89,7 +89,7 @@ pub const REPORT_SCHEMA: u32 = 1;
 
 /// Load and execute every source fixture in `tests/corpus`.
 pub fn run(root: &Path) -> Result<CompatibilityReport, Vec<String>> {
-    let matrix = matrix::load_and_validate().map_err(|problems| problems)?;
+    let matrix = matrix::load_and_validate()?;
     let fixtures = discover(root, &matrix)?;
     let mut cases = Vec::with_capacity(fixtures.len());
     for fixture in fixtures {
diff --git a/src/hir/lower.rs b/src/hir/lower.rs
index 92b1ebd..8ea8dc3 100644
--- a/src/hir/lower.rs
+++ b/src/hir/lower.rs
@@ -22,8 +22,6 @@ pub struct Lowerer<'a> {
     pub symbol_var: HashMap<SymbolId, HirVarId>,
     /// var name node id -> HirVarId (locals during body lowering).
     local_vars: HashMap<NodeId, HirVarId>,
-    /// Lambda expr node id -> HirFuncId.
-    lambda_funcs: HashMap<NodeId, HirFuncId>,
 }
 
 pub fn lower(program: &SemanticProgram) -> (HirProgram, Vec<crate::diagnostics::Diagnostic>) {
@@ -49,7 +47,6 @@ pub fn lower(program: &SemanticProgram) -> (HirProgram, Vec<crate::diagnostics::
         symbol_enum: HashMap::new(),
         symbol_var: HashMap::new(),
         local_vars: HashMap::new(),
-        lambda_funcs: HashMap::new(),
     };
     l.run();
     l.hir.exprs = std::mem::take(&mut l.exprs);
@@ -511,7 +508,7 @@ impl<'a> Lowerer<'a> {
     }
 
     fn lower_stmt(&mut self, s: &Stmt, out: &mut Vec<HirStmt>) {
-        let kind = self.lower_stmt_kind(s, out);
+        let kind = self.lower_stmt_kind(s);
         out.push(HirStmt {
             id: self.next_stmt,
             span: s.span,
@@ -520,7 +517,7 @@ impl<'a> Lowerer<'a> {
         self.next_stmt += 1;
     }
 
-    fn lower_stmt_kind(&mut self, s: &Stmt, out: &mut Vec<HirStmt>) -> HirStmtKind {
+    fn lower_stmt_kind(&mut self, s: &Stmt) -> HirStmtKind {
         match &s.kind {
             StmtKind::Block(b) => HirStmtKind::Block(self.lower_block(b)),
             StmtKind::Var(v) => {
@@ -728,7 +725,7 @@ impl<'a> Lowerer<'a> {
             ExprKind::Null => HirExprKind::Literal(LiteralValue::Null),
             ExprKind::Ident(_) => {
                 if let Some(Resolution::Symbol(sid)) = self.program.resolution.get(&e.id) {
-                    if let Some(vid) = self.symbol_var.get(&sid) {
+                    if let Some(vid) = self.symbol_var.get(sid) {
                         return HirExprKind::VarRef { var: *vid };
                     }
                     // Locals/params registered during body lowering by their
@@ -737,7 +734,7 @@ impl<'a> Lowerer<'a> {
                     if let Some(vid) = self.local_vars.get(&decl) {
                         return HirExprKind::VarRef { var: *vid };
                     }
-                    if let Some(fid) = self.symbol_func.get(&sid) {
+                    if let Some(fid) = self.symbol_func.get(sid) {
                         return HirExprKind::FunctionValue { func: *fid };
                     }
                 }
@@ -865,7 +862,7 @@ impl<'a> Lowerer<'a> {
                     }
                 }
                 if matches!(sym.kind, SymbolKind::Function | SymbolKind::Macro) {
-                    if let Some(fid) = self.symbol_func.get(&sid) {
+                    if let Some(fid) = self.symbol_func.get(sid) {
                         if let Some(class) = self.hir.funcs[*fid as usize].class {
                             return HirMemberTarget::MethodGroup {
                                 class,
@@ -874,7 +871,7 @@ impl<'a> Lowerer<'a> {
                         }
                     }
                 }
-                if let Some(vid) = self.symbol_var.get(&sid) {
+                if let Some(vid) = self.symbol_var.get(sid) {
                     return HirMemberTarget::PlayervarAccess(*vid);
                 }
                 // Class field.
@@ -907,7 +904,7 @@ impl<'a> Lowerer<'a> {
                 BuiltinMember::Invoke => return HirMemberTarget::Invoke,
             }),
             Some(Resolution::PlayervarAccess(sid)) => {
-                if let Some(vid) = self.symbol_var.get(&sid) {
+                if let Some(vid) = self.symbol_var.get(sid) {
                     HirMemberTarget::PlayervarAccess(*vid)
                 } else {
                     HirMemberTarget::Invoke
diff --git a/src/hir/oracle.rs b/src/hir/oracle.rs
index 09922b2..b9b02f6 100644
--- a/src/hir/oracle.rs
+++ b/src/hir/oracle.rs
@@ -3,7 +3,7 @@
 //! before any backend exists. Not a Workshop runtime: external calls are
 //! holes; events never fire.
 
-use crate::diagnostics::{error, Diagnostic, Phase};
+use crate::diagnostics::Diagnostic;
 use crate::hir::*;
 use crate::span::Span;
 use std::collections::HashMap;
@@ -94,8 +94,6 @@ pub struct Oracle<'a> {
     pub options: OracleOptions,
     steps: u64,
     depth: u32,
-    /// Per-loop iteration counters keyed by statement id.
-    loop_counts: HashMap<u32, u64>,
 }
 
 enum Flow {
@@ -121,14 +119,9 @@ impl<'a> Oracle<'a> {
             options: OracleOptions::default(),
             steps: 0,
             depth: 0,
-            loop_counts: HashMap::new(),
         }
     }
 
-    fn diag(&mut self, code: &str, span: Span, msg: String) {
-        self.diagnostics.push(error(Phase::Oracle, code, span, msg));
-    }
-
     fn step(&mut self, span: Span) -> Result<(), OracleError> {
         self.steps += 1;
         if self.steps > self.options.max_steps {
@@ -159,7 +152,7 @@ impl<'a> Oracle<'a> {
                     .globals
                     .get(var)
                     .cloned()
-                    .ok_or_else(|| OracleError::Undefined { span: e.span })?;
+                    .ok_or(OracleError::Undefined { span: e.span })?;
                 Ok(v)
             }
             HirExprKind::Member { base, member } => {
diff --git a/src/hir/validate.rs b/src/hir/validate.rs
index c680f43..2d4c67e 100644
--- a/src/hir/validate.rs
+++ b/src/hir/validate.rs
@@ -9,7 +9,7 @@ use crate::semantic::types::Type;
 
 pub fn validate(hir: &HirProgram) -> Vec<Diagnostic> {
     let mut diags = Vec::new();
-    let mut err = |code: &str, span: crate::span::Span, msg: String, out: &mut Vec<Diagnostic>| {
+    let err = |code: &str, span: crate::span::Span, msg: String, out: &mut Vec<Diagnostic>| {
         out.push(error(Phase::Hir, code, span, msg));
     };
 
@@ -26,22 +26,20 @@ pub fn validate(hir: &HirProgram) -> Vec<Diagnostic> {
                     );
                 }
             }
-            HirExprKind::New { class, .. } => {
-                if *class as usize >= hir.classes.len() {
-                    err(
-                        "HI010",
-                        e.span,
-                        format!("new targets unknown class {class}"),
-                        &mut diags,
-                    );
-                }
+            HirExprKind::New { class, .. } if *class as usize >= hir.classes.len() => {
+                err(
+                    "HI010",
+                    e.span,
+                    format!("new targets unknown class {class}"),
+                    &mut diags,
+                );
             }
             _ => {}
         }
     }
 
     // HI006: assignment targets are lvalues.
-    for (_, e) in hir.exprs.iter().enumerate() {
+    for e in &hir.exprs {
         if let HirExprKind::Assign { target, .. } = &e.kind {
             match &hir.expr(*target).map(|t| &t.kind) {
                 Some(HirExprKind::VarRef { .. })
diff --git a/src/semantic/check.rs b/src/semantic/check.rs
index a73b904..4a362f4 100644
--- a/src/semantic/check.rs
+++ b/src/semantic/check.rs
@@ -510,7 +510,7 @@ impl<'a> Checker<'a> {
                             ..Default::default()
                         },
                     };
-                    if let Err(_) = self.program.tables.declare(self.scope(), sym) {
+                    if self.program.tables.declare(self.scope(), sym).is_err() {
                         self.err(
                             "SM001",
                             v.name.span,
@@ -679,7 +679,7 @@ impl<'a> Checker<'a> {
                             && !scrut.is_external()
                             && !lt.is_error()
                             && !lt.is_external()
-                            && self.conversion(&lt, &scrut).rank() >= 255
+                            && self.conversion(&lt, &scrut).rank() == 255
                         {
                             self.err(
                                 "SM026",
@@ -1017,9 +1017,10 @@ impl<'a> Checker<'a> {
                     tt
                 } else if self.conversion(&tt, &et).rank() < 255 {
                     et
-                } else if self.conversion(&et, &tt).rank() < 255 {
-                    tt
-                } else if tt.is_external() || et.is_external() {
+                } else if self.conversion(&et, &tt).rank() < 255
+                    || tt.is_external()
+                    || et.is_external()
+                {
                     tt
                 } else {
                     Type::Any
@@ -1267,8 +1268,8 @@ impl<'a> Checker<'a> {
     fn check_binary_op(&mut self, op: &BinaryOp, lt: &Type, rt: &Type, span: Span) -> Type {
         match op {
             BinaryOp::Eq | BinaryOp::Ne => {
-                if self.conversion(lt, rt).rank() >= 255
-                    && self.conversion(rt, lt).rank() >= 255
+                if self.conversion(lt, rt).rank() == 255
+                    && self.conversion(rt, lt).rank() == 255
                     && !lt.is_external()
                     && !rt.is_external()
                     && !lt.is_error()
@@ -1559,12 +1560,14 @@ impl<'a> Checker<'a> {
                 {
                     return true;
                 }
-                match self.program.types.get(&base.id) {
-                    Some(Type::Class(_)) => true,
-                    Some(Type::Player) => true,
-                    Some(Type::External(_)) | Some(Type::Any) | None => true,
-                    _ => false,
-                }
+                matches!(
+                    self.program.types.get(&base.id),
+                    Some(Type::Class(_))
+                        | Some(Type::Player)
+                        | Some(Type::External(_))
+                        | Some(Type::Any)
+                        | None
+                )
             }
             _ => self
                 .program
@@ -1669,15 +1672,13 @@ impl<'a> Checker<'a> {
             self.record(expr, ty.clone(), Some(Resolution::Symbol(mid)));
             return ty;
         }
-        if matches!(base_ty, Type::Enum(_)) {
-            if name.name == "Key" || name.name == "Name" {
-                self.record(
-                    expr,
-                    Type::Number,
-                    Some(Resolution::BuiltinMember(BuiltinMember::Key)),
-                );
-                return Type::Number;
-            }
+        if matches!(base_ty, Type::Enum(_)) && (name.name == "Key" || name.name == "Name") {
+            self.record(
+                expr,
+                Type::Number,
+                Some(Resolution::BuiltinMember(BuiltinMember::Key)),
+            );
+            return Type::Number;
         }
         if let Type::Array(elem) = base_ty {
             let bm = match name.name.as_str() {
@@ -2268,14 +2269,13 @@ impl<'a> Checker<'a> {
                 if matches!(
                     bm,
                     BuiltinMember::ArrayModAppend | BuiltinMember::ArrayModRemoveByIndex
-                ) {
-                    if !self.check_lvalue(base) {
-                        self.err(
+                ) && !self.check_lvalue(base)
+                {
+                    self.err(
                             "SM017",
                             base.span,
                             "functions that directly modify arrays require a mutable variable as the source",
                         );
-                    }
                 }
                 Type::Any
             }
@@ -2427,13 +2427,13 @@ impl<'a> Checker<'a> {
                 } else {
                     self.conversion(at, pt)
                 };
-                if c.rank() >= 255 && !pt.is_external() {
+                if c.rank() == 255 && !pt.is_external() {
                     conv_ok = false;
                     break;
                 }
                 rank = rank.max(c.rank() as u32);
             }
-            if conv_ok && best.as_ref().map_or(true, |(_, r)| rank < *r) {
+            if conv_ok && best.as_ref().is_none_or(|(_, r)| rank < *r) {
                 best = Some((sid, rank));
             }
         }
@@ -2465,7 +2465,7 @@ impl<'a> Checker<'a> {
     fn param_info_inner(&mut self, sid: SymbolId) -> (Vec<String>, Vec<bool>) {
         for file in &self.program.project.files {
             if let Some(parsed) = self.program.asts.get(file) {
-                if let Some(info) = find_param_info(parsed, sid, &self.program) {
+                if let Some(info) = find_param_info(parsed, sid, self.program) {
                     return info;
                 }
             }
diff --git a/src/semantic/mod.rs b/src/semantic/mod.rs
index 1880150..87f7c0d 100644
--- a/src/semantic/mod.rs
+++ b/src/semantic/mod.rs
@@ -942,7 +942,7 @@ impl<'a> Builder<'a> {
                 let sym_ty = self.tables.symbol(*mid).ty.clone();
                 let sym_kind = self.tables.symbol(*mid).kind;
                 if sym_kind == SymbolKind::Variable {
-                    self.collect_value_refs(&sym_ty, *tid, &mut targets);
+                    self.collect_value_refs(&sym_ty, &mut targets);
                 } else if sym_kind == SymbolKind::EnumMember {
                     let fts = self
                         .enum_members
@@ -950,7 +950,7 @@ impl<'a> Builder<'a> {
                         .map(|i| i.field_types.clone())
                         .unwrap_or_default();
                     for ft in &fts {
-                        self.collect_value_refs(ft, *tid, &mut targets);
+                        self.collect_value_refs(ft, &mut targets);
                     }
                 }
             }
@@ -991,9 +991,9 @@ impl<'a> Builder<'a> {
         }
     }
 
-    fn collect_value_refs(&mut self, ty: &Type, self_id: SymbolId, out: &mut Vec<SymbolId>) {
+    fn collect_value_refs(&mut self, ty: &Type, out: &mut Vec<SymbolId>) {
         match ty {
-            Type::Array(inner) => self.collect_value_refs(inner, self_id, out),
+            Type::Array(inner) => self.collect_value_refs(inner, out),
             Type::Struct(id) | Type::Enum(id) => out.push(*id),
             Type::GenericInstantiation { def, args } => {
                 let kind = self.tables.symbol(*def).kind;
@@ -1021,7 +1021,7 @@ impl<'a> Builder<'a> {
                         let sym_kind = self.tables.symbol(*mid).kind;
                         if sym_kind == SymbolKind::Variable {
                             let subst_ty = substitute(&sym_ty, &subst);
-                            self.collect_value_refs(&subst_ty, self_id, out);
+                            self.collect_value_refs(&subst_ty, out);
                         } else if sym_kind == SymbolKind::EnumMember {
                             let fts = self
                                 .enum_members
@@ -1030,7 +1030,7 @@ impl<'a> Builder<'a> {
                                 .unwrap_or_default();
                             for ft in &fts {
                                 let subst_ty = substitute(ft, &subst);
-                                self.collect_value_refs(&subst_ty, self_id, out);
+                                self.collect_value_refs(&subst_ty, out);
                             }
                         }
                     }
@@ -1331,11 +1331,8 @@ fn collect_call_names(body: &FuncBody, out: &mut Vec<String>) {
                     }
                 }
             }
-            StmtKind::Return { value } => {
-                if let Some(v) = value {
-                    walk_expr(v, out);
-                }
-            }
+            StmtKind::Return { value: Some(v) } => walk_expr(v, out),
+            StmtKind::Return { value: None } => {}
             StmtKind::Delete { target } => walk_expr(target, out),
             StmtKind::Hook { target, value } => {
                 walk_expr(target, out);
diff --git a/src/semantic/types.rs b/src/semantic/types.rs
index e875b57..98b135f 100644
--- a/src/semantic/types.rs
+++ b/src/semantic/types.rs
@@ -185,7 +185,6 @@ pub fn conversion(
             Conversion::Identity
         }
         (Type::Null, Type::Class(_))
-        | (Type::Null, Type::Any)
         | (Type::Null, Type::Array(_))
         | (Type::Null, Type::String)
         | (Type::Null, Type::Vector)
@@ -294,17 +293,21 @@ pub fn cast_legal(from: &Type, to: &Type) -> bool {
     if from == to {
         return true;
     }
-    match (from, to) {
-        (Type::Error, _) | (_, Type::Error) => true,
-        (_, Type::Any) | (Type::Any, _) => true,
-        (Type::Number, Type::Number) => true,
-        (Type::Class(_), Type::Class(_)) => true,
-        (Type::Number, Type::Class(_)) => true,
-        (Type::Enum(_), Type::Number) | (Type::Number, Type::Enum(_)) => true,
-        (Type::Enum(_), Type::Enum(_)) => true,
-        (Type::External(_), _) | (_, Type::External(_)) => true,
-        _ => false,
-    }
+    matches!(
+        (from, to),
+        (Type::Error, _)
+            | (_, Type::Error)
+            | (_, Type::Any)
+            | (Type::Any, _)
+            | (Type::Number, Type::Number)
+            | (Type::Class(_), Type::Class(_))
+            | (Type::Number, Type::Class(_))
+            | (Type::Enum(_), Type::Number)
+            | (Type::Number, Type::Enum(_))
+            | (Type::Enum(_), Type::Enum(_))
+            | (Type::External(_), _)
+            | (_, Type::External(_))
+    )
 }
 
 /// Whether a type is a "constant or parallel data type" (enum keys, rule
diff --git a/src/syntax/lexer.rs b/src/syntax/lexer.rs
index 1c5fd0e..7b19636 100644
--- a/src/syntax/lexer.rs
+++ b/src/syntax/lexer.rs
@@ -67,7 +67,7 @@ fn lex_with_base(file: FileId, text: &str, base: usize) -> (Vec<Token>, Vec<Diag
                 lx.string(lx.peek(1).unwrap(), Some(StrForm::Interpolated))
             }
             '0'..='9' => lx.number(),
-            '.' if lx.peek(1).map_or(false, |d| d.is_ascii_digit()) => lx.number(),
+            '.' if lx.peek(1).is_some_and(|d| d.is_ascii_digit()) => lx.number(),
             c if c.is_ascii_alphanumeric() || c == '_' => {
                 let kind = lx.identifier();
                 let bool_value = match kind {
@@ -138,7 +138,7 @@ impl<'a> Lexer<'a> {
     }
 
     fn skip_to_line_end(&mut self) {
-        while self.peek(0).map_or(false, |c| c != '\n') {
+        while self.peek(0).is_some_and(|c| c != '\n') {
             self.advance();
         }
     }
@@ -173,7 +173,7 @@ impl<'a> Lexer<'a> {
         if self.peek(0) == Some('.') {
             self.advance();
         }
-        while self.peek(0).map_or(false, |c| c.is_ascii_digit()) {
+        while self.peek(0).is_some_and(|c| c.is_ascii_digit()) {
             self.advance();
         }
         let mut is_real = false;
@@ -185,7 +185,7 @@ impl<'a> Lexer<'a> {
                 Some(c) if c.is_ascii_digit() => {
                     is_real = true;
                     self.advance();
-                    while self.peek(0).map_or(false, |c| c.is_ascii_digit()) {
+                    while self.peek(0).is_some_and(|c| c.is_ascii_digit()) {
                         self.advance();
                     }
                 }
@@ -196,10 +196,10 @@ impl<'a> Lexer<'a> {
             }
         }
         // Malformed trailing form: "1.2.3" or "5abc" -> Error over the run.
-        if self.peek(0) == Some('.') || self.peek(0).map_or(false, |c| c.is_ascii_alphabetic()) {
+        if self.peek(0) == Some('.') || self.peek(0).is_some_and(|c| c.is_ascii_alphabetic()) {
             while self
                 .peek(0)
-                .map_or(false, |c| c.is_ascii_alphanumeric() || c == '.')
+                .is_some_and(|c| c.is_ascii_alphanumeric() || c == '.')
             {
                 self.advance();
             }
@@ -226,7 +226,7 @@ impl<'a> Lexer<'a> {
     fn identifier(&mut self) -> TokenKind {
         while self
             .peek(0)
-            .map_or(false, |c| c.is_ascii_alphanumeric() || c == '_')
+            .is_some_and(|c| c.is_ascii_alphanumeric() || c == '_')
         {
             self.advance();
         }
diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs
index bde7087..7b18c04 100644
--- a/src/syntax/parser.rs
+++ b/src/syntax/parser.rs
@@ -2801,13 +2801,14 @@ impl<'a> Parser<'a> {
         self.silent += 1;
         let t = self.parse_type_inner(false);
         self.silent -= 1;
-        if t.is_err() {
-            self.pos = save;
-            self.open_delims.truncate(save_delims);
-            self.diagnostics.truncate(saved_len);
-            None
-        } else {
-            Some(t.unwrap())
+        match t {
+            Ok(t) => Some(t),
+            Err(_) => {
+                self.pos = save;
+                self.open_delims.truncate(save_delims);
+                self.diagnostics.truncate(saved_len);
+                None
+            }
         }
     }
 
diff --git a/src/workshop.rs b/src/workshop.rs
index 9bf5f66..20c6484 100644
--- a/src/workshop.rs
+++ b/src/workshop.rs
@@ -785,9 +785,7 @@ impl<'a> Lowerer<'a> {
             );
             return None;
         };
-        let Some(binding) = self.external_binding(expr.span, &name, &namespace) else {
-            return None;
-        };
+        let binding = self.external_binding(expr.span, &name, &namespace)?;
         let ExternalBinding::Event(info) = binding else {
             self.unsupported(
                 expr.span,
@@ -1508,14 +1506,14 @@ impl<'a> Lowerer<'a> {
                 step,
                 body,
             } => {
-                if self.auto_for_uses_condition(*var, *end) {
-                    if matches!(
+                if self.auto_for_uses_condition(*var, *end)
+                    && matches!(
                         self.hir.expr(*step).map(|expr| &expr.kind),
                         Some(HirExprKind::Postfix { .. })
-                    ) {
-                        return self
-                            .lower_condition_auto_for(stmt.span, *var, *start, *end, *step, body);
-                    }
+                    )
+                {
+                    return self
+                        .lower_condition_auto_for(stmt.span, *var, *start, *end, *step, body);
                 }
                 let Ok(start) = self.lower_value(*start) else {
                     return Vec::new();
diff --git a/tests/hir.rs b/tests/hir.rs
index 9721106..96e07e5 100644
--- a/tests/hir.rs
+++ b/tests/hir.rs
@@ -38,26 +38,18 @@ fn find_func(hir: &deltin_rs::hir::HirProgram, name: &str) -> deltin_rs::hir::Hi
 fn lowering_produces_program() {
     let text = "globalvar Number x = 5;\nrecursive Number fact(Number n) { if (n > 0) { return n * fact(n - 1); } return 1; }\nrule: \"\" {\n    define y = fact(3);\n}\n";
     let (hir, diags) = pipeline(text);
-    assert!(
-        diags.iter().filter(|d| d.is_error()).next().is_none(),
-        "{:?}",
-        diags
-    );
+    assert!(diags.iter().find(|d| d.is_error()).is_none(), "{:?}", diags);
     assert!(!hir.funcs.is_empty());
     assert!(!hir.rules.is_empty());
     assert!(!hir.vars.is_empty());
-    assert!(hir.exprs.len() > 0);
-    // Every function has a body or is external.
-    for f in &hir.funcs {
-        assert!(f.span.start >= 0);
-    }
+    assert!(!hir.exprs.is_empty());
 }
 
 #[test]
 fn lowering_preserves_spans() {
     let text = "rule: \"\" {\n    define a = 1 + 2;\n}\n";
     let (hir, diags) = pipeline(text);
-    assert!(diags.iter().filter(|d| d.is_error()).next().is_none());
+    assert!(diags.iter().find(|d| d.is_error()).is_none());
     for e in &hir.exprs {
         // Spans must be within a plausible range for this file.
         assert!(e.span.end <= 1000);
@@ -85,11 +77,7 @@ recursive Number fact(Number n) {
 }
 "#;
     let (hir, diags) = pipeline(text);
-    assert!(
-        diags.iter().filter(|d| d.is_error()).next().is_none(),
-        "{:?}",
-        diags
-    );
+    assert!(diags.iter().find(|d| d.is_error()).is_none(), "{:?}", diags);
     let fid = find_func(&hir, "fact");
     let result = run_oracle(
         &hir,
@@ -115,11 +103,7 @@ Number sum(Number[] values) {
 }
 "#;
     let (hir, diags) = pipeline(text);
-    assert!(
-        diags.iter().filter(|d| d.is_error()).next().is_none(),
-        "{:?}",
-        diags
-    );
+    assert!(diags.iter().find(|d| d.is_error()).is_none(), "{:?}", diags);
     let fid = find_func(&hir, "sum");
     let result = run_oracle(
         &hir,
@@ -150,11 +134,7 @@ Number classify(Number v) {
 }
 "#;
     let (hir, diags) = pipeline(text);
-    assert!(
-        diags.iter().filter(|d| d.is_error()).next().is_none(),
-        "{:?}",
-        diags
-    );
+    assert!(diags.iter().find(|d| d.is_error()).is_none(), "{:?}", diags);
     let fid = find_func(&hir, "classify");
     // Fallthrough: case 1 runs then falls into case 2 (out = 3).
     let result = run_oracle(
@@ -172,7 +152,7 @@ Number classify(Number v) {
 fn oracle_loop_limit() {
     let text = "Number loop() { while (true) { } return 0; }\n";
     let (hir, diags) = pipeline(text);
-    assert!(diags.iter().filter(|d| d.is_error()).next().is_none());
+    assert!(diags.iter().find(|d| d.is_error()).is_none());
     let fid = find_func(&hir, "loop");
     let result = run_oracle(
         &hir,
@@ -195,7 +175,7 @@ fn oracle_loop_limit() {
 fn oracle_external_boundary() {
     let text = "Number f(Number a): a + ExternalValue();\n";
     let (hir, diags) = pipeline(text);
-    assert!(diags.iter().filter(|d| d.is_error()).next().is_none());
+    assert!(diags.iter().find(|d| d.is_error()).is_none());
     let fid = find_func(&hir, "f");
     let result = run_oracle(
         &hir,
diff --git a/tests/parse.rs b/tests/parse.rs
index a052f19..f5a5e08 100644
--- a/tests/parse.rs
+++ b/tests/parse.rs
@@ -261,7 +261,7 @@ fn parser_auto_for_forms() {
         "rule: \"\" {\n    for (Number i = 0; i < 10; i++) {}\n}\n",
         "rule: \"\" {\n    for (i = 0; i < 10; i = i + 1) {}\n}\n",
     ] {
-        let (ast, diags) = parse(text);
+        let (_ast, diags) = parse(text);
         assert!(
             errors(&diags).is_empty(),
             "case {text:?}: {:?}",
@@ -348,7 +348,7 @@ fn parser_doc_comments_associated() {
 #[test]
 fn parser_single_value_struct() {
     let text = "rule: \"\" {\n    Number value = {0};\n}\n";
-    let (ast, diags) = parse(text);
+    let (_ast, diags) = parse(text);
     assert!(errors(&diags).is_empty(), "{:?}", errors(&diags));
 }
 
diff --git a/tests/semantic.rs b/tests/semantic.rs
index 0b3446a..bbcdb34 100644
--- a/tests/semantic.rs
+++ b/tests/semantic.rs
@@ -154,7 +154,7 @@ fn diagnostics_have_provenance() {
     assert!(has_code(&diags, "SM004"));
     for d in &diags {
         assert_eq!(d.phase, deltin_rs::diagnostics::Phase::Semantic);
-        assert!(d.primary.start < d.primary.end || d.primary.start == d.primary.end);
+        assert!(d.primary.start <= d.primary.end);
     }
 }