Remove failing, unused namegen test

Author: archaephyrryx

src/codegen/mod.rs

@@ -5315,95 +5315,6 @@ mod tests {
         let output = produce_string_gencode(&module, &outer.call());
         println!("{}", output);
     }
-
-    #[test]
-    fn test_namegen_deflate_analogue() {
-        use crate::helper::*;
-        let mut module = FormatModule::new();
-
-        let block = module.define_format(
-            "deflate.block",
-            record([
-                ("final", u8()),
-                ("type", u8()),
-                ("data", {
-                    Format::Match(
-                        Box::new(var("type")),
-                        vec![
-                            (Pattern::U8(0), fmt_variant("uncompressed", opaque_bytes())),
-                            (Pattern::U8(1), fmt_variant("fixed_huffman", opaque_bytes())),
-                            (
-                                Pattern::U8(2),
-                                fmt_variant("dynamic_huffman", opaque_bytes()),
-                            ),
-                        ],
-                    )
-                }),
-            ]),
-        );
-
-        let f = record([
-            (
-                "foobar",
-                repeat_until_last(
-                    lambda("x", expr_eq(record_proj(var("x"), "final"), Expr::U8(1))),
-                    block.call(),
-                ),
-            ),
-            (
-                "xyzzy",
-                compute(flat_map(
-                    lambda(
-                        "x",
-                        expr_match(
-                            record_proj(var("x"), "data"),
-                            vec![
-                                (
-                                    Pattern::variant("uncompressed", Pattern::binding("y")),
-                                    var("y"),
-                                ),
-                                (
-                                    Pattern::variant("fixed_huffman", Pattern::binding("y")),
-                                    var("y"),
-                                ),
-                                (
-                                    Pattern::variant("dynamic_huffman", Pattern::binding("y")),
-                                    var("y"),
-                                ),
-                            ],
-                        ),
-                    ),
-                    var("foobar"),
-                )),
-            ),
-            (
-                "deadbeef",
-                compute(flat_map_list(
-                    lambda_tuple(
-                        ["buffer", "symbol"],
-                        expr_match(
-                            var("symbol"),
-                            vec![
-                                (
-                                    Pattern::variant("literal", Pattern::binding("b")),
-                                    Expr::U8(0),
-                                ),
-                                (
-                                    Pattern::variant("reference", Pattern::binding("r")),
-                                    Expr::U8(0),
-                                ),
-                            ],
-                        ),
-                    ),
-                    ValueType::Base(BaseType::U8),
-                    var("xyzzy"),
-                )),
-            ),
-        ]);
-        let main = module.define_format("main", f);
-        let output = produce_string_gencode(&module, &main.call());
-        println!("{}", output);
-    }
 }
 
 mod __impls {

src/codegen/rust_ast/mod.rs

@@ -649,7 +649,6 @@ pub(crate) struct RustTypeDecl {
 }
 
 impl RustTypeDecl {
-    #[expect(dead_code)]
     pub(crate) fn lt_param(&self) -> Option<&RustLt> {
         self.lt.as_ref()
     }