inline dbg

crates/compiler/can/src/builtins.rs

@@ -87,6 +87,7 @@ macro_rules! map_symbol_to_lowlevel_and_arity {
                 LowLevel::PtrCast => unimplemented!(),
                 LowLevel::RefCountInc => unimplemented!(),
                 LowLevel::RefCountDec => unimplemented!(),
+                LowLevel::Dbg => unimplemented!(),
 
                 // these are not implemented, not sure why
                 LowLevel::StrFromInt => unimplemented!(),

crates/compiler/can/src/copy.rs

@@ -611,6 +611,16 @@ fn deep_copy_expr_help<C: CopyEnv>(env: &mut C, copied: &mut Vec<Variable>, expr
             lookups_in_cond: lookups_in_cond.to_vec(),
         },
 
+        Dbg {
+            loc_condition,
+            loc_continuation,
+            variable,
+        } => Dbg {
+            loc_condition: Box::new(loc_condition.map(|e| go_help!(e))),
+            loc_continuation: Box::new(loc_continuation.map(|e| go_help!(e))),
+            variable: sub!(*variable),
+        },
+
         TypedHole(v) => TypedHole(sub!(*v)),
 
         RuntimeError(err) => RuntimeError(err.clone()),

crates/compiler/can/src/expr.rs

@@ -240,6 +240,12 @@ pub enum Expr {
         lookups_in_cond: Vec<ExpectLookup>,
     },
 
+    Dbg {
+        loc_condition: Box<Loc<Expr>>,
+        loc_continuation: Box<Loc<Expr>>,
+        variable: Variable,
+    },
+
     /// Rendered as empty box in editor
     TypedHole(Variable),
 
@@ -295,6 +301,8 @@ impl Expr {
             Self::Expect { .. } => Category::Expect,
             Self::ExpectFx { .. } => Category::Expect,
 
+            Self::Dbg { .. } => Category::Expect,
+
             // these nodes place no constraints on the expression's type
             Self::TypedHole(_) | Self::RuntimeError(..) => Category::Unknown,
         }
@@ -1826,6 +1834,28 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
             }
         }
 
+        Dbg {
+            loc_condition,
+            loc_continuation,
+            variable,
+        } => {
+            let loc_condition = Loc {
+                region: loc_condition.region,
+                value: inline_calls(var_store, loc_condition.value),
+            };
+
+            let loc_continuation = Loc {
+                region: loc_continuation.region,
+                value: inline_calls(var_store, loc_continuation.value),
+            };
+
+            Dbg {
+                loc_condition: Box::new(loc_condition),
+                loc_continuation: Box::new(loc_continuation),
+                variable,
+            }
+        }
+
         LetRec(defs, loc_expr, mark) => {
             let mut new_defs = Vec::with_capacity(defs.len());
 
@@ -2740,6 +2770,9 @@ fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
             }
             | Expr::ExpectFx {
                 loc_continuation, ..
+            }
+            | Expr::Dbg {
+                loc_continuation, ..
             } => {
                 stack.push(&loc_continuation.value);
 

crates/compiler/can/src/module.rs

@@ -952,24 +952,17 @@ fn fix_values_captured_in_closure_expr(
         Expect {
             loc_condition,
             loc_continuation,
-            lookups_in_cond: _,
-        } => {
-            fix_values_captured_in_closure_expr(
-                &mut loc_condition.value,
-                no_capture_symbols,
-                closure_captures,
-            );
-            fix_values_captured_in_closure_expr(
-                &mut loc_continuation.value,
-                no_capture_symbols,
-                closure_captures,
-            );
+            ..
         }
-
-        ExpectFx {
+        | ExpectFx {
             loc_condition,
             loc_continuation,
-            lookups_in_cond: _,
+            ..
+        }
+        | Dbg {
+            loc_condition,
+            loc_continuation,
+            ..
         } => {
             fix_values_captured_in_closure_expr(
                 &mut loc_condition.value,

crates/compiler/can/src/traverse.rs

@@ -268,8 +268,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
             loc_continuation,
             lookups_in_cond: _,
         } => {
-            // TODO: what type does an expect have? bool
-            visitor.visit_expr(&loc_condition.value, loc_condition.region, Variable::NULL);
+            visitor.visit_expr(&loc_condition.value, loc_condition.region, Variable::BOOL);
             visitor.visit_expr(
                 &loc_continuation.value,
                 loc_continuation.region,
@@ -281,8 +280,19 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
             loc_continuation,
             lookups_in_cond: _,
         } => {
-            // TODO: what type does an expect have? bool
-            visitor.visit_expr(&loc_condition.value, loc_condition.region, Variable::NULL);
+            visitor.visit_expr(&loc_condition.value, loc_condition.region, Variable::BOOL);
+            visitor.visit_expr(
+                &loc_continuation.value,
+                loc_continuation.region,
+                Variable::NULL,
+            );
+        }
+        Expr::Dbg {
+            variable,
+            loc_condition,
+            loc_continuation,
+        } => {
+            visitor.visit_expr(&loc_condition.value, loc_condition.region, *variable);
             visitor.visit_expr(
                 &loc_continuation.value,
                 loc_continuation.region,