formatting

compiler/mono/src/borrow.rs

@@ -410,6 +410,7 @@ impl<'a> BorrowInfState<'a> {
             LowLevel {
                 op,
                 opt_closure_layout,
+                ..
             } => {
                 use roc_module::low_level::LowLevel::*;
                 match op {

compiler/mono/src/inc_dec.rs

@@ -1,4 +1,4 @@
-use crate::borrow::{ParamMap, BORROWED, OWNED};
+use crate::borrow::{ParamMap, BORROWED};
 use crate::ir::{Expr, JoinPointId, ModifyRc, Param, Proc, Stmt};
 use crate::layout::Layout;
 use bumpalo::collections::Vec;
@@ -471,10 +471,11 @@ impl<'a> Context<'a> {
                             let mut b = Stmt::Let(z, v, l, b);
 
                             if !ps[1].borrow {
-                                b = Stmt::Refcounting(
-                                    ModifyRc::Inc(arguments[2], 2),
-                                    self.arena.alloc(b),
-                                )
+                                // b = Stmt::Refcounting(
+                                //     ModifyRc::Inc(arguments[2], 2),
+                                //     self.arena.alloc(b),
+                                // )
+                                todo!();
                             }
 
                             &*self.arena.alloc(b)
@@ -799,10 +800,7 @@ impl<'a> Context<'a> {
 
                 use crate::ir::CallType;
                 let stmt = match &call.call_type {
-                    CallType::LowLevel {
-                        op,
-                        opt_closure_layout: _,
-                    } => {
+                    CallType::LowLevel { op, .. } => {
                         let ps = crate::borrow::lowlevel_borrow_signature(self.arena, *op);
                         self.add_dec_after_lowlevel(call.arguments, ps, cont, &invoke_live_vars)
                     }

compiler/mono/src/ir.rs

@@ -1061,10 +1061,7 @@ impl<'a> Call<'a> {
                     .text("CallByPointer ")
                     .append(alloc.intersperse(it, " "))
             }
-            LowLevel {
-                op: lowlevel,
-                opt_closure_layout: _,
-            } => {
+            LowLevel { op: lowlevel, .. } => {
                 let it = arguments.iter().map(|s| symbol_to_doc(alloc, *s));
 
                 alloc
@@ -2668,7 +2665,9 @@ macro_rules! match_on_closure_argument {
                     lambda_set,
                     $closure_data_symbol,
                     |top_level_function, closure_data, function_layout| self::Call {
-                        call_type: CallType::LowLevel { op: $op, opt_closure_layout: Some(function_layout) },
+                        call_type: CallType::LowLevel {
+                                op: $op, opt_closure_layout: Some(function_layout),
+                            },
                         arguments: arena.alloc([$($x,)* top_level_function, closure_data]),
                     },
                     arena.alloc(top_level).full(),