we can use if let chains now!

trilogy-ir/src/ir/assignment.rs

···
 
         let op = match ast.strategy {
             Direct(..) => {
-                if let expression::Value::Reference(id) = &lhs.value {
-                    if !id.is_mutable {
-                        converter.error(Error::AssignedImmutableBinding {
-                            name: *id.clone(),
-                            assignment: span,
-                        });
-                    }
+                if let expression::Value::Reference(id) = &lhs.value
+                    && !id.is_mutable
+                {
+                    converter.error(Error::AssignedImmutableBinding {
+                        name: *id.clone(),
+                        assignment: span,
+                    });
                 }
                 return Expression::assignment(span, Assignment { lhs, rhs });
             }

trilogy-ir/src/scope.rs

···
     }
 
     pub fn declare(&mut self, name: String, is_mutable: bool, span: Span) -> Id {
-        if self.pseudo {
-            if let Some(declared) = self.declared_pseudo(&name) {
-                return declared.clone();
-            }
+        if self.pseudo
+            && let Some(declared) = self.declared_pseudo(&name)
+        {
+            return declared.clone();
         }
         self.symbols.reusable(name, is_mutable, span).clone()
     }

trilogy-llvm/src/expression/mod.rs

···
         name: &str,
     ) -> Option<PointerValue<'ctx>> {
         // Possibly a static module reference, which we can support very easily and efficiently
-        if let Value::Reference(module) = &module_ref.value {
-            if let Some(module) =
+        if let Value::Reference(module) = &module_ref.value
+            && let Some(module) =
                 self.globals
                     .get(&module.id)
                     .and_then(|global| match &global.head {
···
                         Head::ExternalModule(path) => Some(path.to_owned()),
                         _ => None,
                     })
-            {
-                let target = self.allocate_value(name);
-                let declared = self
-                    .module
-                    .get_function(&format!("{module}::{}", ident.as_ref()))
-                    .unwrap();
-                self.call_internal(target, declared, &[]);
-                return Some(target);
-            }
+        {
+            let target = self.allocate_value(name);
+            let declared = self
+                .module
+                .get_function(&format!("{module}::{}", ident.as_ref()))
+                .unwrap();
+            self.call_internal(target, declared, &[]);
+            return Some(target);
         }
 
         let module_value = self.compile_expression(module_ref, "")?;

trilogy-parser/src/syntax/array_literal.rs

···
         parser: &mut Parser,
     ) -> SyntaxResult<Result<Self, (Option<Token>, Pattern)>> {
         let spread = parser.expect(OpDotDot).ok();
-        if let Some(spread) = &spread {
-            if let Ok(dot) = parser.expect(OpDot) {
-                parser.error(ErrorKind::TripleDot { dot: dot.span }.at(spread.span));
-            }
+        if let Some(spread) = &spread
+            && let Ok(dot) = parser.expect(OpDot)
+        {
+            parser.error(ErrorKind::TripleDot { dot: dot.span }.at(spread.span));
         }
         let expression = Expression::parse_parameter_list(parser)?;
         match expression {

trilogy-parser/src/syntax/set_literal.rs

···
         parser: &mut Parser,
     ) -> SyntaxResult<Result<Self, (Option<Token>, Pattern)>> {
         let spread = parser.expect(OpDotDot).ok();
-        if let Some(spread) = &spread {
-            if let Ok(dot) = parser.expect(OpDot) {
-                parser.error(ErrorKind::TripleDot { dot: dot.span }.at(spread.span));
-            }
+        if let Some(spread) = &spread
+            && let Ok(dot) = parser.expect(OpDot)
+        {
+            parser.error(ErrorKind::TripleDot { dot: dot.span }.at(spread.span));
         }
         let expression = Expression::parse_parameter_list(parser)?;
         match expression {

trilogy-scanner/src/scanner.rs

···
             if ch == '"' {
                 return self.make_token(on_end).with_value(content);
             }
-            if let Some(on_continue) = on_continue {
-                if ch == '$' && self.expect(|ch| ch == '{').is_some() {
-                    return self.make_token(on_continue).with_value(content);
-                }
+            if let Some(on_continue) = on_continue
+                && ch == '$'
+                && self.expect(|ch| ch == '{').is_some()
+            {
+                return self.make_token(on_continue).with_value(content);
             }
             if ch == '\\' {
                 ch = match self.escape_sequence() {

trilogy/src/runtime/runtime_error.rs

···
             eprintln!("{frame}");
 
             if report.is_none() {
-                if let Some((_, loc)) = &frame.expr {
-                    if let Some(local) = loc
+                if let Some((_, loc)) = &frame.expr
+                    && let Some(local) = loc
                         .file
                         .parse::<Url>()
                         .ok()
                         .and_then(|url| url.to_file_path().ok())
                         .map(|path| path.display().to_string())
+                {
                     // Ariadne hates us
-                    {
-                        let span = cache.span(&local, loc.span);
-                        report = Some(
-                            ariadne::Report::build(ReportKind::Error, &loc.file, span.1.start)
-                                .with_message(format!("{}", self.error))
-                                .with_label(
-                                    Label::new(span)
-                                        .with_color(primary)
-                                        .with_message("in this expression"),
-                                ),
-                        );
-                    }
+                    let span = cache.span(&local, loc.span);
+                    report = Some(
+                        ariadne::Report::build(ReportKind::Error, &loc.file, span.1.start)
+                            .with_message(format!("{}", self.error))
+                            .with_label(
+                                Label::new(span)
+                                    .with_color(primary)
+                                    .with_message("in this expression"),
+                            ),
+                    );
                 }
             }
         }