Support passing values into dbg with the pipe operator

In order to desugar `dbg` in a pipeline we need to allow a bare `dbg`
node in desugaring and only report it as an error if the bare node
survives to the next step of canonicalization. This means we move the
error code out of `desugar_expr` and into `canonicalize_expr`. This is
much simpler to do now that these functions use the same `env` struct,
since previously we would have had to pass down extra args to
`canonicalize_expr`. Sharing the `env` struct means that we also don't
have to worry about calculating `line_info` more than once.

crates/compiler/test_mono/generated/pizza_dbg.txt

@@ -0,0 +1,59 @@
+procedure Inspect.278 (Inspect.279, Inspect.277):
+    let Inspect.318 : Str = CallByName Num.96 Inspect.277;
+    let Inspect.317 : Str = CallByName Inspect.63 Inspect.279 Inspect.318;
+    dec Inspect.318;
+    ret Inspect.317;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.322 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.321 : Str = CallByName Inspect.64 Inspect.322;
+    ret Inspect.321;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : I64 = CallByName Inspect.57 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName Inspect.278 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
+    ret Inspect.313;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.320;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure Num.19 (#Attr.2, #Attr.3):
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
+
+procedure Num.96 (#Attr.2):
+    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.282;
+
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
+
+procedure Test.0 ():
+    let Test.4 : I64 = 1i64;
+    let Test.5 : Str = CallByName Inspect.33 Test.4;
+    dbg Test.5;
+    dec Test.5;
+    let Test.9 : I64 = 2i64;
+    let Test.3 : I64 = CallByName Num.19 Test.4 Test.9;
+    let Test.6 : Str = CallByName Inspect.33 Test.3;
+    dbg Test.6;
+    dec Test.6;
+    ret Test.3;

crates/compiler/test_mono/src/tests.rs

@@ -3295,6 +3295,18 @@ fn dbg_inside_string() {
     )
 }
 
+#[mono_test]
+fn pizza_dbg() {
+    indoc!(
+        r#"
+        1
+        |> dbg
+        |> Num.add 2
+        |> dbg
+        "#
+    )
+}
+
 #[mono_test]
 fn linked_list_reverse() {
     indoc!(