diff --git a/misc/codegen/generators/rustgen.py b/misc/codegen/generators/rustgen.py
index 9b850c3cf1b..6fa5d4a05ec 100644
--- a/misc/codegen/generators/rustgen.py
+++ b/misc/codegen/generators/rustgen.py
@@ -20,7 +20,7 @@ def _get_type(t: str) -> str:
         case "int":
             return "usize"
         case _ if t[0].isupper():
-            return "trap::Label"
+            return f"{t}TrapLabel"
         case "boolean":
             assert False, "boolean unsupported"
         case _:
@@ -57,6 +57,15 @@ def _get_properties(
         yield cls, p
 
 
+def _get_ancestors(
+    cls: schema.Class, lookup: dict[str, schema.Class]
+) -> typing.Iterable[schema.Class]:
+    for b in cls.bases:
+        base = lookup[b]
+        yield base
+        yield from _get_ancestors(base, lookup)
+
+
 class Processor:
     def __init__(self, data: schema.Schema):
         self._classmap = data.classes
@@ -69,14 +78,15 @@ class Processor:
                 _get_field(c, p)
                 for c, p in _get_properties(cls, self._classmap)
                 if "rust_skip" not in p.pragmas and not p.synth
-            ],
+            ] if not cls.derived else [],
+            ancestors=sorted(set(a.name for a in _get_ancestors(cls, self._classmap))),
             table_name=inflection.tableize(cls.name),
         )
 
     def get_classes(self):
         ret = {"": []}
         for k, cls in self._classmap.items():
-            if not cls.synth and not cls.derived:
+            if not cls.synth:
                 ret.setdefault(cls.group, []).append(self._get_class(cls.name))
         return ret
 
diff --git a/misc/codegen/lib/rust.py b/misc/codegen/lib/rust.py
index ac7bf4313d3..0f4b410db70 100644
--- a/misc/codegen/lib/rust.py
+++ b/misc/codegen/lib/rust.py
@@ -110,8 +110,9 @@ class Field:
 @dataclasses.dataclass
 class Class:
     name: str
-    table_name: str
+    table_name: str | None = None
     fields: list[Field] = dataclasses.field(default_factory=list)
+    ancestors: list[str] = dataclasses.field(default_factory=list)
 
     @property
     def single_field_entries(self):
diff --git a/misc/codegen/templates/rust_classes.mustache b/misc/codegen/templates/rust_classes.mustache
index 3b415683d5f..f749733b2bd 100644
--- a/misc/codegen/templates/rust_classes.mustache
+++ b/misc/codegen/templates/rust_classes.mustache
@@ -2,48 +2,77 @@
 
 #![cfg_attr(any(), rustfmt::skip)]
 
-use crate::trap::{TrapId, TrapEntry};
-use codeql_extractor::trap;
+use crate::trap;
 {{#classes}}
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct {{name}}TrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for {{name}}TrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<{{name}}TrapLabel> for trap::TrapId<{{name}}> {
+    fn from(value: {{name}}TrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for {{name}}TrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<{{name}}TrapLabel> for trap::Arg {
+    fn from(value: {{name}}TrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+{{#table_name}}
 #[derive(Debug)]
 pub struct {{name}} {
-    pub id: TrapId,
+    pub id: trap::TrapId<{{name}}>,
     {{#fields}}
     pub {{field_name}}: {{type}},
     {{/fields}}
 }
 
-impl TrapEntry for {{name}} {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for {{name}} {
+    fn class_name() -> &'static str { "{{name}}" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
         {{#single_field_entries}}
-        out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{#fields}}, self.{{field_name}}.into(){{/fields}}]);
+        out.add_tuple("{{table_name}}", vec![id.into(){{#fields}}, self.{{field_name}}.into(){{/fields}}]);
         {{/single_field_entries}}
         {{#fields}}
         {{#is_predicate}}
         if self.{{field_name}} {
-            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id)]);
+            out.add_tuple("{{table_name}}", vec![id.into()]);
         }
         {{/is_predicate}}
         {{#is_optional}}
         {{^is_repeated}}
         if let Some(v) = self.{{field_name}} {
-            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("{{table_name}}", vec![id.into(), v.into()]);
         }
         {{/is_repeated}}
         {{/is_optional}}
         {{#is_repeated}}
         for (i, v) in self.{{field_name}}.into_iter().enumerate() {
             {{^is_optional}}
-            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
+            out.add_tuple("{{table_name}}", vec![id.into(){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
             {{/is_optional}}
             {{#is_optional}}
             if let Some(v) = v {
-                out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
+                out.add_tuple("{{table_name}}", vec![id.into(){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
             }
             {{/is_optional}}
         }
@@ -51,4 +80,26 @@ impl TrapEntry for {{name}} {
         {{/fields}}
     }
 }
+{{/table_name}}
+{{^table_name}}
+{{! virtual class, make it unbuildable }}
+pub struct {{name}} {
+    unused: ()
+}
+{{/table_name}}
+
+impl trap::TrapClass for {{name}} {
+    type Label = {{name}}TrapLabel;
+}
+{{/classes}}
+
+// Conversions
+{{#classes}}
+{{#ancestors}}
+impl From<{{name}}TrapLabel> for {{.}}TrapLabel {
+    fn from(value: {{name}}TrapLabel) -> Self {
+        value.0.into()
+    }
+}
+{{/ancestors}}
 {{/classes}}
diff --git a/rust/extractor/src/generated/.generated.list b/rust/extractor/src/generated/.generated.list
index b404b2e7541..fd7cc5c6614 100644
--- a/rust/extractor/src/generated/.generated.list
+++ b/rust/extractor/src/generated/.generated.list
@@ -1,2 +1,2 @@
 mod.rs 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e
-top.rs 7150acaeab0b57039ca9f2ed20311229aab5fd48b533f13410ecc34fd8e3bda0 7150acaeab0b57039ca9f2ed20311229aab5fd48b533f13410ecc34fd8e3bda0
+top.rs e06dc90de4abd57719786fd5e49e6ea3089ec3ec167c64446e25d95a16b1714c e06dc90de4abd57719786fd5e49e6ea3089ec3ec167c64446e25d95a16b1714c
diff --git a/rust/extractor/src/generated/top.rs b/rust/extractor/src/generated/top.rs
index de6d2106c1d..084fdbb61f0 100644
--- a/rust/extractor/src/generated/top.rs
+++ b/rust/extractor/src/generated/top.rs
@@ -2,1222 +2,5008 @@
 
 #![cfg_attr(any(), rustfmt::skip)]
 
-use crate::trap::{TrapId, TrapEntry};
-use codeql_extractor::trap;
+use crate::trap;
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ElementTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ElementTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ElementTrapLabel> for trap::TrapId<Element> {
+    fn from(value: ElementTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ElementTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ElementTrapLabel> for trap::Arg {
+    fn from(value: ElementTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Element {
+    pub id: trap::TrapId<Element>,
+}
+
+impl trap::TrapEntry for Element {
+    fn class_name() -> &'static str { "Element" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("elements", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Element {
+    type Label = ElementTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LocatableTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LocatableTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LocatableTrapLabel> for trap::TrapId<Locatable> {
+    fn from(value: LocatableTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LocatableTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LocatableTrapLabel> for trap::Arg {
+    fn from(value: LocatableTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Locatable {
+    pub id: trap::TrapId<Locatable>,
+}
+
+impl trap::TrapEntry for Locatable {
+    fn class_name() -> &'static str { "Locatable" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("locatables", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Locatable {
+    type Label = LocatableTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct AstNodeTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for AstNodeTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<AstNodeTrapLabel> for trap::TrapId<AstNode> {
+    fn from(value: AstNodeTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for AstNodeTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<AstNodeTrapLabel> for trap::Arg {
+    fn from(value: AstNodeTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct AstNode {
+    pub id: trap::TrapId<AstNode>,
+}
+
+impl trap::TrapEntry for AstNode {
+    fn class_name() -> &'static str { "AstNode" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("ast_nodes", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for AstNode {
+    type Label = AstNodeTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct DeclarationTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for DeclarationTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<DeclarationTrapLabel> for trap::TrapId<Declaration> {
+    fn from(value: DeclarationTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for DeclarationTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<DeclarationTrapLabel> for trap::Arg {
+    fn from(value: DeclarationTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Declaration {
+    pub id: trap::TrapId<Declaration>,
+}
+
+impl trap::TrapEntry for Declaration {
+    fn class_name() -> &'static str { "Declaration" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("declarations", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Declaration {
+    type Label = DeclarationTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ExprTrapLabel> for trap::TrapId<Expr> {
+    fn from(value: ExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ExprTrapLabel> for trap::Arg {
+    fn from(value: ExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Expr {
+    pub id: trap::TrapId<Expr>,
+}
+
+impl trap::TrapEntry for Expr {
+    fn class_name() -> &'static str { "Expr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("exprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Expr {
+    type Label = ExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LabelTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LabelTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LabelTrapLabel> for trap::TrapId<Label> {
+    fn from(value: LabelTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LabelTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LabelTrapLabel> for trap::Arg {
+    fn from(value: LabelTrapLabel) -> Self {
+        value.0.into()
+    }
+}
 
 #[derive(Debug)]
 pub struct Label {
-    pub id: TrapId,
+    pub id: trap::TrapId<Label>,
     pub name: String,
 }
 
-impl TrapEntry for Label {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for Label {
+    fn class_name() -> &'static str { "Label" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("labels", vec![trap::Arg::Label(id), self.name.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("labels", vec![id.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for Label {
+    type Label = LabelTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct MatchArmTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for MatchArmTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<MatchArmTrapLabel> for trap::TrapId<MatchArm> {
+    fn from(value: MatchArmTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for MatchArmTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<MatchArmTrapLabel> for trap::Arg {
+    fn from(value: MatchArmTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct MatchArm {
-    pub id: TrapId,
-    pub pat: trap::Label,
-    pub guard: Option<trap::Label>,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<MatchArm>,
+    pub pat: PatTrapLabel,
+    pub guard: Option<ExprTrapLabel>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for MatchArm {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for MatchArm {
+    fn class_name() -> &'static str { "MatchArm" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("match_arms", vec![trap::Arg::Label(id), self.pat.into(), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("match_arms", vec![id.into(), self.pat.into(), self.expr.into()]);
         if let Some(v) = self.guard {
-            out.add_tuple("match_arm_guards", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("match_arm_guards", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for MatchArm {
+    type Label = MatchArmTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct PatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for PatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<PatTrapLabel> for trap::TrapId<Pat> {
+    fn from(value: PatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for PatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<PatTrapLabel> for trap::Arg {
+    fn from(value: PatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Pat {
+    pub id: trap::TrapId<Pat>,
+}
+
+impl trap::TrapEntry for Pat {
+    fn class_name() -> &'static str { "Pat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("pats", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Pat {
+    type Label = PatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RecordFieldPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RecordFieldPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RecordFieldPatTrapLabel> for trap::TrapId<RecordFieldPat> {
+    fn from(value: RecordFieldPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RecordFieldPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RecordFieldPatTrapLabel> for trap::Arg {
+    fn from(value: RecordFieldPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RecordFieldPat {
-    pub id: TrapId,
+    pub id: trap::TrapId<RecordFieldPat>,
     pub name: String,
-    pub pat: trap::Label,
+    pub pat: PatTrapLabel,
 }
 
-impl TrapEntry for RecordFieldPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RecordFieldPat {
+    fn class_name() -> &'static str { "RecordFieldPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("record_field_pats", vec![trap::Arg::Label(id), self.name.into(), self.pat.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("record_field_pats", vec![id.into(), self.name.into(), self.pat.into()]);
+    }
+}
+
+impl trap::TrapClass for RecordFieldPat {
+    type Label = RecordFieldPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RecordLitFieldTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RecordLitFieldTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RecordLitFieldTrapLabel> for trap::TrapId<RecordLitField> {
+    fn from(value: RecordLitFieldTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RecordLitFieldTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RecordLitFieldTrapLabel> for trap::Arg {
+    fn from(value: RecordLitFieldTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct RecordLitField {
-    pub id: TrapId,
+    pub id: trap::TrapId<RecordLitField>,
     pub name: String,
-    pub expr: trap::Label,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for RecordLitField {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RecordLitField {
+    fn class_name() -> &'static str { "RecordLitField" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("record_lit_fields", vec![trap::Arg::Label(id), self.name.into(), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("record_lit_fields", vec![id.into(), self.name.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for RecordLitField {
+    type Label = RecordLitFieldTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct StmtTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for StmtTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<StmtTrapLabel> for trap::TrapId<Stmt> {
+    fn from(value: StmtTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for StmtTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<StmtTrapLabel> for trap::Arg {
+    fn from(value: StmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Stmt {
+    pub id: trap::TrapId<Stmt>,
+}
+
+impl trap::TrapEntry for Stmt {
+    fn class_name() -> &'static str { "Stmt" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("stmts", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Stmt {
+    type Label = StmtTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct TypeRefTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for TypeRefTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<TypeRefTrapLabel> for trap::TrapId<TypeRef> {
+    fn from(value: TypeRefTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for TypeRefTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<TypeRefTrapLabel> for trap::Arg {
+    fn from(value: TypeRefTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct TypeRef {
-    pub id: TrapId,
+    pub id: trap::TrapId<TypeRef>,
 }
 
-impl TrapEntry for TypeRef {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for TypeRef {
+    fn class_name() -> &'static str { "TypeRef" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("type_refs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("type_refs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for TypeRef {
+    type Label = TypeRefTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ArrayExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ArrayExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ArrayExprTrapLabel> for trap::TrapId<ArrayExpr> {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ArrayExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ArrayExprTrapLabel> for trap::Arg {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
-pub struct Unimplemented {
-    pub id: TrapId,
+pub struct ArrayExpr {
+    pub id: trap::TrapId<ArrayExpr>,
 }
 
-impl TrapEntry for Unimplemented {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ArrayExpr {
+    fn class_name() -> &'static str { "ArrayExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("unimplementeds", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("array_exprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for ArrayExpr {
+    type Label = ArrayExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct AwaitExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for AwaitExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<AwaitExprTrapLabel> for trap::TrapId<AwaitExpr> {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for AwaitExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<AwaitExprTrapLabel> for trap::Arg {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct AwaitExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<AwaitExpr>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for AwaitExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for AwaitExpr {
+    fn class_name() -> &'static str { "AwaitExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("await_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("await_exprs", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for AwaitExpr {
+    type Label = AwaitExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BecomeExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BecomeExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BecomeExprTrapLabel> for trap::TrapId<BecomeExpr> {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BecomeExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BecomeExprTrapLabel> for trap::Arg {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct BecomeExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<BecomeExpr>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for BecomeExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BecomeExpr {
+    fn class_name() -> &'static str { "BecomeExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("become_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("become_exprs", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for BecomeExpr {
+    type Label = BecomeExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BinaryOpExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BinaryOpExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BinaryOpExprTrapLabel> for trap::TrapId<BinaryOpExpr> {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BinaryOpExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BinaryOpExprTrapLabel> for trap::Arg {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct BinaryOpExpr {
-    pub id: TrapId,
-    pub lhs: trap::Label,
-    pub rhs: trap::Label,
+    pub id: trap::TrapId<BinaryOpExpr>,
+    pub lhs: ExprTrapLabel,
+    pub rhs: ExprTrapLabel,
     pub op: Option<String>,
 }
 
-impl TrapEntry for BinaryOpExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BinaryOpExpr {
+    fn class_name() -> &'static str { "BinaryOpExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("binary_op_exprs", vec![trap::Arg::Label(id), self.lhs.into(), self.rhs.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("binary_op_exprs", vec![id.into(), self.lhs.into(), self.rhs.into()]);
         if let Some(v) = self.op {
-            out.add_tuple("binary_op_expr_ops", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("binary_op_expr_ops", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for BinaryOpExpr {
+    type Label = BinaryOpExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BindPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BindPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BindPatTrapLabel> for trap::TrapId<BindPat> {
+    fn from(value: BindPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BindPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BindPatTrapLabel> for trap::Arg {
+    fn from(value: BindPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct BindPat {
-    pub id: TrapId,
+    pub id: trap::TrapId<BindPat>,
     pub binding_id: String,
-    pub subpat: Option<trap::Label>,
+    pub subpat: Option<PatTrapLabel>,
 }
 
-impl TrapEntry for BindPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BindPat {
+    fn class_name() -> &'static str { "BindPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("bind_pats", vec![trap::Arg::Label(id), self.binding_id.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("bind_pats", vec![id.into(), self.binding_id.into()]);
         if let Some(v) = self.subpat {
-            out.add_tuple("bind_pat_subpats", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("bind_pat_subpats", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for BindPat {
+    type Label = BindPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BlockExprBaseTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BlockExprBaseTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BlockExprBaseTrapLabel> for trap::TrapId<BlockExprBase> {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BlockExprBaseTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BlockExprBaseTrapLabel> for trap::Arg {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct BlockExprBase {
+    pub id: trap::TrapId<BlockExprBase>,
+}
+
+impl trap::TrapEntry for BlockExprBase {
+    fn class_name() -> &'static str { "BlockExprBase" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("block_expr_bases", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for BlockExprBase {
+    type Label = BlockExprBaseTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BoxExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BoxExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BoxExprTrapLabel> for trap::TrapId<BoxExpr> {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BoxExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BoxExprTrapLabel> for trap::Arg {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct BoxExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<BoxExpr>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for BoxExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BoxExpr {
+    fn class_name() -> &'static str { "BoxExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("box_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("box_exprs", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for BoxExpr {
+    type Label = BoxExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BoxPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BoxPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BoxPatTrapLabel> for trap::TrapId<BoxPat> {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BoxPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BoxPatTrapLabel> for trap::Arg {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct BoxPat {
-    pub id: TrapId,
-    pub inner: trap::Label,
+    pub id: trap::TrapId<BoxPat>,
+    pub inner: PatTrapLabel,
 }
 
-impl TrapEntry for BoxPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BoxPat {
+    fn class_name() -> &'static str { "BoxPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("box_pats", vec![trap::Arg::Label(id), self.inner.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("box_pats", vec![id.into(), self.inner.into()]);
+    }
+}
+
+impl trap::TrapClass for BoxPat {
+    type Label = BoxPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BreakExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BreakExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BreakExprTrapLabel> for trap::TrapId<BreakExpr> {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BreakExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BreakExprTrapLabel> for trap::Arg {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct BreakExpr {
-    pub id: TrapId,
-    pub expr: Option<trap::Label>,
-    pub label: Option<trap::Label>,
+    pub id: trap::TrapId<BreakExpr>,
+    pub expr: Option<ExprTrapLabel>,
+    pub label: Option<LabelTrapLabel>,
 }
 
-impl TrapEntry for BreakExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BreakExpr {
+    fn class_name() -> &'static str { "BreakExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("break_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("break_exprs", vec![id.into()]);
         if let Some(v) = self.expr {
-            out.add_tuple("break_expr_exprs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("break_expr_exprs", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.label {
-            out.add_tuple("break_expr_labels", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("break_expr_labels", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for BreakExpr {
+    type Label = BreakExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct CallExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for CallExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<CallExprTrapLabel> for trap::TrapId<CallExpr> {
+    fn from(value: CallExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for CallExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<CallExprTrapLabel> for trap::Arg {
+    fn from(value: CallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct CallExpr {
-    pub id: TrapId,
-    pub callee: trap::Label,
-    pub args: Vec<trap::Label>,
+    pub id: trap::TrapId<CallExpr>,
+    pub callee: ExprTrapLabel,
+    pub args: Vec<ExprTrapLabel>,
     pub is_assignee_expr: bool,
 }
 
-impl TrapEntry for CallExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for CallExpr {
+    fn class_name() -> &'static str { "CallExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("call_exprs", vec![trap::Arg::Label(id), self.callee.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("call_exprs", vec![id.into(), self.callee.into()]);
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("call_expr_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("call_expr_args", vec![id.into(), i.into(), v.into()]);
         }
         if self.is_assignee_expr {
-            out.add_tuple("call_expr_is_assignee_expr", vec![trap::Arg::Label(id)]);
+            out.add_tuple("call_expr_is_assignee_expr", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for CallExpr {
+    type Label = CallExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct CastExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for CastExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<CastExprTrapLabel> for trap::TrapId<CastExpr> {
+    fn from(value: CastExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for CastExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<CastExprTrapLabel> for trap::Arg {
+    fn from(value: CastExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct CastExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
-    pub type_ref: trap::Label,
+    pub id: trap::TrapId<CastExpr>,
+    pub expr: ExprTrapLabel,
+    pub type_ref: TypeRefTrapLabel,
 }
 
-impl TrapEntry for CastExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for CastExpr {
+    fn class_name() -> &'static str { "CastExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("cast_exprs", vec![trap::Arg::Label(id), self.expr.into(), self.type_ref.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("cast_exprs", vec![id.into(), self.expr.into(), self.type_ref.into()]);
+    }
+}
+
+impl trap::TrapClass for CastExpr {
+    type Label = CastExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ClosureExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ClosureExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ClosureExprTrapLabel> for trap::TrapId<ClosureExpr> {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ClosureExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ClosureExprTrapLabel> for trap::Arg {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct ClosureExpr {
-    pub id: TrapId,
-    pub args: Vec<trap::Label>,
-    pub arg_types: Vec<Option<trap::Label>>,
-    pub ret_type: Option<trap::Label>,
-    pub body: trap::Label,
+    pub id: trap::TrapId<ClosureExpr>,
+    pub args: Vec<PatTrapLabel>,
+    pub arg_types: Vec<Option<TypeRefTrapLabel>>,
+    pub ret_type: Option<TypeRefTrapLabel>,
+    pub body: ExprTrapLabel,
     pub closure_kind: String,
     pub is_move: bool,
 }
 
-impl TrapEntry for ClosureExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ClosureExpr {
+    fn class_name() -> &'static str { "ClosureExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("closure_exprs", vec![trap::Arg::Label(id), self.body.into(), self.closure_kind.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("closure_exprs", vec![id.into(), self.body.into(), self.closure_kind.into()]);
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("closure_expr_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("closure_expr_args", vec![id.into(), i.into(), v.into()]);
         }
         for (i, v) in self.arg_types.into_iter().enumerate() {
             if let Some(v) = v {
-                out.add_tuple("closure_expr_arg_types", vec![trap::Arg::Label(id), i.into(), v.into()]);
+                out.add_tuple("closure_expr_arg_types", vec![id.into(), i.into(), v.into()]);
             }
         }
         if let Some(v) = self.ret_type {
-            out.add_tuple("closure_expr_ret_types", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("closure_expr_ret_types", vec![id.into(), v.into()]);
         }
         if self.is_move {
-            out.add_tuple("closure_expr_is_move", vec![trap::Arg::Label(id)]);
+            out.add_tuple("closure_expr_is_move", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for ClosureExpr {
+    type Label = ClosureExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ConstBlockPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ConstBlockPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ConstBlockPatTrapLabel> for trap::TrapId<ConstBlockPat> {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ConstBlockPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ConstBlockPatTrapLabel> for trap::Arg {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct ConstBlockPat {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<ConstBlockPat>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for ConstBlockPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ConstBlockPat {
+    fn class_name() -> &'static str { "ConstBlockPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("const_block_pats", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("const_block_pats", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for ConstBlockPat {
+    type Label = ConstBlockPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ConstExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ConstExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ConstExprTrapLabel> for trap::TrapId<ConstExpr> {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ConstExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ConstExprTrapLabel> for trap::Arg {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct ConstExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<ConstExpr>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for ConstExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ConstExpr {
+    fn class_name() -> &'static str { "ConstExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("const_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("const_exprs", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for ConstExpr {
+    type Label = ConstExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ContinueExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ContinueExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ContinueExprTrapLabel> for trap::TrapId<ContinueExpr> {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ContinueExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ContinueExprTrapLabel> for trap::Arg {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct ContinueExpr {
-    pub id: TrapId,
-    pub label: Option<trap::Label>,
+    pub id: trap::TrapId<ContinueExpr>,
+    pub label: Option<LabelTrapLabel>,
 }
 
-impl TrapEntry for ContinueExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ContinueExpr {
+    fn class_name() -> &'static str { "ContinueExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("continue_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("continue_exprs", vec![id.into()]);
         if let Some(v) = self.label {
-            out.add_tuple("continue_expr_labels", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("continue_expr_labels", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for ContinueExpr {
+    type Label = ContinueExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ExprStmtTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ExprStmtTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ExprStmtTrapLabel> for trap::TrapId<ExprStmt> {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ExprStmtTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ExprStmtTrapLabel> for trap::Arg {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct ExprStmt {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<ExprStmt>,
+    pub expr: ExprTrapLabel,
     pub has_semicolon: bool,
 }
 
-impl TrapEntry for ExprStmt {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ExprStmt {
+    fn class_name() -> &'static str { "ExprStmt" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("expr_stmts", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("expr_stmts", vec![id.into(), self.expr.into()]);
         if self.has_semicolon {
-            out.add_tuple("expr_stmt_has_semicolon", vec![trap::Arg::Label(id)]);
+            out.add_tuple("expr_stmt_has_semicolon", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for ExprStmt {
+    type Label = ExprStmtTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct FieldExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for FieldExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<FieldExprTrapLabel> for trap::TrapId<FieldExpr> {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for FieldExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<FieldExprTrapLabel> for trap::Arg {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct FieldExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<FieldExpr>,
+    pub expr: ExprTrapLabel,
     pub name: String,
 }
 
-impl TrapEntry for FieldExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for FieldExpr {
+    fn class_name() -> &'static str { "FieldExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("field_exprs", vec![trap::Arg::Label(id), self.expr.into(), self.name.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("field_exprs", vec![id.into(), self.expr.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for FieldExpr {
+    type Label = FieldExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct FunctionTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for FunctionTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<FunctionTrapLabel> for trap::TrapId<Function> {
+    fn from(value: FunctionTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for FunctionTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<FunctionTrapLabel> for trap::Arg {
+    fn from(value: FunctionTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct Function {
-    pub id: TrapId,
+    pub id: trap::TrapId<Function>,
     pub name: String,
-    pub body: trap::Label,
+    pub body: ExprTrapLabel,
 }
 
-impl TrapEntry for Function {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for Function {
+    fn class_name() -> &'static str { "Function" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("functions", vec![trap::Arg::Label(id), self.name.into(), self.body.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("functions", vec![id.into(), self.name.into(), self.body.into()]);
+    }
+}
+
+impl trap::TrapClass for Function {
+    type Label = FunctionTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct IfExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for IfExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<IfExprTrapLabel> for trap::TrapId<IfExpr> {
+    fn from(value: IfExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for IfExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<IfExprTrapLabel> for trap::Arg {
+    fn from(value: IfExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct IfExpr {
-    pub id: TrapId,
-    pub condition: trap::Label,
-    pub then: trap::Label,
-    pub else_: Option<trap::Label>,
+    pub id: trap::TrapId<IfExpr>,
+    pub condition: ExprTrapLabel,
+    pub then: ExprTrapLabel,
+    pub else_: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for IfExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for IfExpr {
+    fn class_name() -> &'static str { "IfExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("if_exprs", vec![trap::Arg::Label(id), self.condition.into(), self.then.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("if_exprs", vec![id.into(), self.condition.into(), self.then.into()]);
         if let Some(v) = self.else_ {
-            out.add_tuple("if_expr_elses", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("if_expr_elses", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for IfExpr {
+    type Label = IfExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct IndexExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for IndexExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<IndexExprTrapLabel> for trap::TrapId<IndexExpr> {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for IndexExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<IndexExprTrapLabel> for trap::Arg {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct IndexExpr {
-    pub id: TrapId,
-    pub base: trap::Label,
-    pub index: trap::Label,
+    pub id: trap::TrapId<IndexExpr>,
+    pub base: ExprTrapLabel,
+    pub index: ExprTrapLabel,
     pub is_assignee_expr: bool,
 }
 
-impl TrapEntry for IndexExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for IndexExpr {
+    fn class_name() -> &'static str { "IndexExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("index_exprs", vec![trap::Arg::Label(id), self.base.into(), self.index.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("index_exprs", vec![id.into(), self.base.into(), self.index.into()]);
         if self.is_assignee_expr {
-            out.add_tuple("index_expr_is_assignee_expr", vec![trap::Arg::Label(id)]);
+            out.add_tuple("index_expr_is_assignee_expr", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for IndexExpr {
+    type Label = IndexExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct InlineAsmExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for InlineAsmExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<InlineAsmExprTrapLabel> for trap::TrapId<InlineAsmExpr> {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for InlineAsmExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<InlineAsmExprTrapLabel> for trap::Arg {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct InlineAsmExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<InlineAsmExpr>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for InlineAsmExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for InlineAsmExpr {
+    fn class_name() -> &'static str { "InlineAsmExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("inline_asm_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("inline_asm_exprs", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for InlineAsmExpr {
+    type Label = InlineAsmExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ItemStmtTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ItemStmtTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ItemStmtTrapLabel> for trap::TrapId<ItemStmt> {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ItemStmtTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ItemStmtTrapLabel> for trap::Arg {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct ItemStmt {
-    pub id: TrapId,
+    pub id: trap::TrapId<ItemStmt>,
 }
 
-impl TrapEntry for ItemStmt {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ItemStmt {
+    fn class_name() -> &'static str { "ItemStmt" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("item_stmts", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("item_stmts", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for ItemStmt {
+    type Label = ItemStmtTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LetExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LetExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LetExprTrapLabel> for trap::TrapId<LetExpr> {
+    fn from(value: LetExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LetExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LetExprTrapLabel> for trap::Arg {
+    fn from(value: LetExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct LetExpr {
-    pub id: TrapId,
-    pub pat: trap::Label,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<LetExpr>,
+    pub pat: PatTrapLabel,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for LetExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for LetExpr {
+    fn class_name() -> &'static str { "LetExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("let_exprs", vec![trap::Arg::Label(id), self.pat.into(), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("let_exprs", vec![id.into(), self.pat.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for LetExpr {
+    type Label = LetExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LetStmtTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LetStmtTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LetStmtTrapLabel> for trap::TrapId<LetStmt> {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LetStmtTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LetStmtTrapLabel> for trap::Arg {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct LetStmt {
-    pub id: TrapId,
-    pub pat: trap::Label,
-    pub type_ref: Option<trap::Label>,
-    pub initializer: Option<trap::Label>,
-    pub else_: Option<trap::Label>,
+    pub id: trap::TrapId<LetStmt>,
+    pub pat: PatTrapLabel,
+    pub type_ref: Option<TypeRefTrapLabel>,
+    pub initializer: Option<ExprTrapLabel>,
+    pub else_: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for LetStmt {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for LetStmt {
+    fn class_name() -> &'static str { "LetStmt" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("let_stmts", vec![trap::Arg::Label(id), self.pat.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("let_stmts", vec![id.into(), self.pat.into()]);
         if let Some(v) = self.type_ref {
-            out.add_tuple("let_stmt_type_refs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("let_stmt_type_refs", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.initializer {
-            out.add_tuple("let_stmt_initializers", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("let_stmt_initializers", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.else_ {
-            out.add_tuple("let_stmt_elses", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("let_stmt_elses", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for LetStmt {
+    type Label = LetStmtTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LitPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LitPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LitPatTrapLabel> for trap::TrapId<LitPat> {
+    fn from(value: LitPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LitPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LitPatTrapLabel> for trap::Arg {
+    fn from(value: LitPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct LitPat {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<LitPat>,
+    pub expr: ExprTrapLabel,
 }
 
-impl TrapEntry for LitPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for LitPat {
+    fn class_name() -> &'static str { "LitPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("lit_pats", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("lit_pats", vec![id.into(), self.expr.into()]);
+    }
+}
+
+impl trap::TrapClass for LitPat {
+    type Label = LitPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LiteralExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LiteralExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LiteralExprTrapLabel> for trap::TrapId<LiteralExpr> {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LiteralExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LiteralExprTrapLabel> for trap::Arg {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct LiteralExpr {
-    pub id: TrapId,
+    pub id: trap::TrapId<LiteralExpr>,
 }
 
-impl TrapEntry for LiteralExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for LiteralExpr {
+    fn class_name() -> &'static str { "LiteralExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("literal_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("literal_exprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for LiteralExpr {
+    type Label = LiteralExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LoopExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for LoopExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<LoopExprTrapLabel> for trap::TrapId<LoopExpr> {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for LoopExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<LoopExprTrapLabel> for trap::Arg {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct LoopExpr {
-    pub id: TrapId,
-    pub body: trap::Label,
-    pub label: Option<trap::Label>,
+    pub id: trap::TrapId<LoopExpr>,
+    pub body: ExprTrapLabel,
+    pub label: Option<LabelTrapLabel>,
 }
 
-impl TrapEntry for LoopExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for LoopExpr {
+    fn class_name() -> &'static str { "LoopExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("loop_exprs", vec![trap::Arg::Label(id), self.body.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("loop_exprs", vec![id.into(), self.body.into()]);
         if let Some(v) = self.label {
-            out.add_tuple("loop_expr_labels", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("loop_expr_labels", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for LoopExpr {
+    type Label = LoopExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct MatchExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for MatchExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<MatchExprTrapLabel> for trap::TrapId<MatchExpr> {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for MatchExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<MatchExprTrapLabel> for trap::Arg {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct MatchExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
-    pub branches: Vec<trap::Label>,
+    pub id: trap::TrapId<MatchExpr>,
+    pub expr: ExprTrapLabel,
+    pub branches: Vec<MatchArmTrapLabel>,
 }
 
-impl TrapEntry for MatchExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for MatchExpr {
+    fn class_name() -> &'static str { "MatchExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("match_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("match_exprs", vec![id.into(), self.expr.into()]);
         for (i, v) in self.branches.into_iter().enumerate() {
-            out.add_tuple("match_expr_branches", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("match_expr_branches", vec![id.into(), i.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for MatchExpr {
+    type Label = MatchExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct MethodCallExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for MethodCallExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<MethodCallExprTrapLabel> for trap::TrapId<MethodCallExpr> {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for MethodCallExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<MethodCallExprTrapLabel> for trap::Arg {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct MethodCallExpr {
-    pub id: TrapId,
-    pub receiver: trap::Label,
+    pub id: trap::TrapId<MethodCallExpr>,
+    pub receiver: ExprTrapLabel,
     pub method_name: String,
-    pub args: Vec<trap::Label>,
-    pub generic_args: Option<trap::Label>,
+    pub args: Vec<ExprTrapLabel>,
+    pub generic_args: Option<UnimplementedTrapLabel>,
 }
 
-impl TrapEntry for MethodCallExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for MethodCallExpr {
+    fn class_name() -> &'static str { "MethodCallExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("method_call_exprs", vec![trap::Arg::Label(id), self.receiver.into(), self.method_name.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("method_call_exprs", vec![id.into(), self.receiver.into(), self.method_name.into()]);
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("method_call_expr_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("method_call_expr_args", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.generic_args {
-            out.add_tuple("method_call_expr_generic_args", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("method_call_expr_generic_args", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for MethodCallExpr {
+    type Label = MethodCallExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct MissingExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for MissingExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<MissingExprTrapLabel> for trap::TrapId<MissingExpr> {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for MissingExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<MissingExprTrapLabel> for trap::Arg {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct MissingExpr {
-    pub id: TrapId,
+    pub id: trap::TrapId<MissingExpr>,
 }
 
-impl TrapEntry for MissingExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for MissingExpr {
+    fn class_name() -> &'static str { "MissingExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("missing_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("missing_exprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for MissingExpr {
+    type Label = MissingExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct MissingPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for MissingPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<MissingPatTrapLabel> for trap::TrapId<MissingPat> {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for MissingPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<MissingPatTrapLabel> for trap::Arg {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct MissingPat {
-    pub id: TrapId,
+    pub id: trap::TrapId<MissingPat>,
 }
 
-impl TrapEntry for MissingPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for MissingPat {
+    fn class_name() -> &'static str { "MissingPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("missing_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("missing_pats", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for MissingPat {
+    type Label = MissingPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ModuleTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ModuleTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ModuleTrapLabel> for trap::TrapId<Module> {
+    fn from(value: ModuleTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ModuleTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ModuleTrapLabel> for trap::Arg {
+    fn from(value: ModuleTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct Module {
-    pub id: TrapId,
-    pub declarations: Vec<trap::Label>,
+    pub id: trap::TrapId<Module>,
+    pub declarations: Vec<DeclarationTrapLabel>,
 }
 
-impl TrapEntry for Module {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for Module {
+    fn class_name() -> &'static str { "Module" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("modules", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("modules", vec![id.into()]);
         for (i, v) in self.declarations.into_iter().enumerate() {
-            out.add_tuple("module_declarations", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("module_declarations", vec![id.into(), i.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for Module {
+    type Label = ModuleTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct OffsetOfExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for OffsetOfExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<OffsetOfExprTrapLabel> for trap::TrapId<OffsetOfExpr> {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for OffsetOfExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<OffsetOfExprTrapLabel> for trap::Arg {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct OffsetOfExpr {
-    pub id: TrapId,
-    pub container: trap::Label,
+    pub id: trap::TrapId<OffsetOfExpr>,
+    pub container: TypeRefTrapLabel,
     pub fields: Vec<String>,
 }
 
-impl TrapEntry for OffsetOfExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for OffsetOfExpr {
+    fn class_name() -> &'static str { "OffsetOfExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("offset_of_exprs", vec![trap::Arg::Label(id), self.container.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("offset_of_exprs", vec![id.into(), self.container.into()]);
         for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("offset_of_expr_fields", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("offset_of_expr_fields", vec![id.into(), i.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for OffsetOfExpr {
+    type Label = OffsetOfExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct OrPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for OrPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<OrPatTrapLabel> for trap::TrapId<OrPat> {
+    fn from(value: OrPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for OrPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<OrPatTrapLabel> for trap::Arg {
+    fn from(value: OrPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct OrPat {
-    pub id: TrapId,
-    pub args: Vec<trap::Label>,
+    pub id: trap::TrapId<OrPat>,
+    pub args: Vec<PatTrapLabel>,
 }
 
-impl TrapEntry for OrPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for OrPat {
+    fn class_name() -> &'static str { "OrPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("or_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("or_pats", vec![id.into()]);
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("or_pat_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("or_pat_args", vec![id.into(), i.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for OrPat {
+    type Label = OrPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct PathExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for PathExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<PathExprTrapLabel> for trap::TrapId<PathExpr> {
+    fn from(value: PathExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for PathExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<PathExprTrapLabel> for trap::Arg {
+    fn from(value: PathExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct PathExpr {
-    pub id: TrapId,
-    pub path: trap::Label,
+    pub id: trap::TrapId<PathExpr>,
+    pub path: UnimplementedTrapLabel,
 }
 
-impl TrapEntry for PathExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for PathExpr {
+    fn class_name() -> &'static str { "PathExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("path_exprs", vec![trap::Arg::Label(id), self.path.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("path_exprs", vec![id.into(), self.path.into()]);
+    }
+}
+
+impl trap::TrapClass for PathExpr {
+    type Label = PathExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct PathPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for PathPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<PathPatTrapLabel> for trap::TrapId<PathPat> {
+    fn from(value: PathPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for PathPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<PathPatTrapLabel> for trap::Arg {
+    fn from(value: PathPatTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct PathPat {
-    pub id: TrapId,
-    pub path: trap::Label,
+    pub id: trap::TrapId<PathPat>,
+    pub path: UnimplementedTrapLabel,
 }
 
-impl TrapEntry for PathPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for PathPat {
+    fn class_name() -> &'static str { "PathPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("path_pats", vec![trap::Arg::Label(id), self.path.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("path_pats", vec![id.into(), self.path.into()]);
+    }
+}
+
+impl trap::TrapClass for PathPat {
+    type Label = PathPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RangeExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RangeExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RangeExprTrapLabel> for trap::TrapId<RangeExpr> {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RangeExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RangeExprTrapLabel> for trap::Arg {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct RangeExpr {
-    pub id: TrapId,
-    pub lhs: Option<trap::Label>,
-    pub rhs: Option<trap::Label>,
+    pub id: trap::TrapId<RangeExpr>,
+    pub lhs: Option<ExprTrapLabel>,
+    pub rhs: Option<ExprTrapLabel>,
     pub is_inclusive: bool,
 }
 
-impl TrapEntry for RangeExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RangeExpr {
+    fn class_name() -> &'static str { "RangeExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("range_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("range_exprs", vec![id.into()]);
         if let Some(v) = self.lhs {
-            out.add_tuple("range_expr_lhs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("range_expr_lhs", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.rhs {
-            out.add_tuple("range_expr_rhs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("range_expr_rhs", vec![id.into(), v.into()]);
         }
         if self.is_inclusive {
-            out.add_tuple("range_expr_is_inclusive", vec![trap::Arg::Label(id)]);
+            out.add_tuple("range_expr_is_inclusive", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RangeExpr {
+    type Label = RangeExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RangePatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RangePatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RangePatTrapLabel> for trap::TrapId<RangePat> {
+    fn from(value: RangePatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RangePatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RangePatTrapLabel> for trap::Arg {
+    fn from(value: RangePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RangePat {
-    pub id: TrapId,
-    pub start: Option<trap::Label>,
-    pub end: Option<trap::Label>,
+    pub id: trap::TrapId<RangePat>,
+    pub start: Option<PatTrapLabel>,
+    pub end: Option<PatTrapLabel>,
 }
 
-impl TrapEntry for RangePat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RangePat {
+    fn class_name() -> &'static str { "RangePat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("range_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("range_pats", vec![id.into()]);
         if let Some(v) = self.start {
-            out.add_tuple("range_pat_starts", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("range_pat_starts", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.end {
-            out.add_tuple("range_pat_ends", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("range_pat_ends", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RangePat {
+    type Label = RangePatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RecordLitExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RecordLitExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RecordLitExprTrapLabel> for trap::TrapId<RecordLitExpr> {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RecordLitExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RecordLitExprTrapLabel> for trap::Arg {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RecordLitExpr {
-    pub id: TrapId,
-    pub path: Option<trap::Label>,
-    pub fields: Vec<trap::Label>,
-    pub spread: Option<trap::Label>,
+    pub id: trap::TrapId<RecordLitExpr>,
+    pub path: Option<UnimplementedTrapLabel>,
+    pub fields: Vec<RecordLitFieldTrapLabel>,
+    pub spread: Option<ExprTrapLabel>,
     pub has_ellipsis: bool,
     pub is_assignee_expr: bool,
 }
 
-impl TrapEntry for RecordLitExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RecordLitExpr {
+    fn class_name() -> &'static str { "RecordLitExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("record_lit_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("record_lit_exprs", vec![id.into()]);
         if let Some(v) = self.path {
-            out.add_tuple("record_lit_expr_paths", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("record_lit_expr_paths", vec![id.into(), v.into()]);
         }
         for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("record_lit_expr_fields", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("record_lit_expr_fields", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.spread {
-            out.add_tuple("record_lit_expr_spreads", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("record_lit_expr_spreads", vec![id.into(), v.into()]);
         }
         if self.has_ellipsis {
-            out.add_tuple("record_lit_expr_has_ellipsis", vec![trap::Arg::Label(id)]);
+            out.add_tuple("record_lit_expr_has_ellipsis", vec![id.into()]);
         }
         if self.is_assignee_expr {
-            out.add_tuple("record_lit_expr_is_assignee_expr", vec![trap::Arg::Label(id)]);
+            out.add_tuple("record_lit_expr_is_assignee_expr", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RecordLitExpr {
+    type Label = RecordLitExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RecordPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RecordPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RecordPatTrapLabel> for trap::TrapId<RecordPat> {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RecordPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RecordPatTrapLabel> for trap::Arg {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RecordPat {
-    pub id: TrapId,
-    pub path: Option<trap::Label>,
-    pub args: Vec<trap::Label>,
+    pub id: trap::TrapId<RecordPat>,
+    pub path: Option<UnimplementedTrapLabel>,
+    pub args: Vec<RecordFieldPatTrapLabel>,
     pub has_ellipsis: bool,
 }
 
-impl TrapEntry for RecordPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RecordPat {
+    fn class_name() -> &'static str { "RecordPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("record_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("record_pats", vec![id.into()]);
         if let Some(v) = self.path {
-            out.add_tuple("record_pat_paths", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("record_pat_paths", vec![id.into(), v.into()]);
         }
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("record_pat_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("record_pat_args", vec![id.into(), i.into(), v.into()]);
         }
         if self.has_ellipsis {
-            out.add_tuple("record_pat_has_ellipsis", vec![trap::Arg::Label(id)]);
+            out.add_tuple("record_pat_has_ellipsis", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RecordPat {
+    type Label = RecordPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RefExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RefExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RefExprTrapLabel> for trap::TrapId<RefExpr> {
+    fn from(value: RefExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RefExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RefExprTrapLabel> for trap::Arg {
+    fn from(value: RefExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RefExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<RefExpr>,
+    pub expr: ExprTrapLabel,
     pub is_raw: bool,
     pub is_mut: bool,
 }
 
-impl TrapEntry for RefExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RefExpr {
+    fn class_name() -> &'static str { "RefExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("ref_exprs", vec![trap::Arg::Label(id), self.expr.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("ref_exprs", vec![id.into(), self.expr.into()]);
         if self.is_raw {
-            out.add_tuple("ref_expr_is_raw", vec![trap::Arg::Label(id)]);
+            out.add_tuple("ref_expr_is_raw", vec![id.into()]);
         }
         if self.is_mut {
-            out.add_tuple("ref_expr_is_mut", vec![trap::Arg::Label(id)]);
+            out.add_tuple("ref_expr_is_mut", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RefExpr {
+    type Label = RefExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RefPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RefPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RefPatTrapLabel> for trap::TrapId<RefPat> {
+    fn from(value: RefPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RefPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RefPatTrapLabel> for trap::Arg {
+    fn from(value: RefPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RefPat {
-    pub id: TrapId,
-    pub pat: trap::Label,
+    pub id: trap::TrapId<RefPat>,
+    pub pat: PatTrapLabel,
     pub is_mut: bool,
 }
 
-impl TrapEntry for RefPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RefPat {
+    fn class_name() -> &'static str { "RefPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("ref_pats", vec![trap::Arg::Label(id), self.pat.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("ref_pats", vec![id.into(), self.pat.into()]);
         if self.is_mut {
-            out.add_tuple("ref_pat_is_mut", vec![trap::Arg::Label(id)]);
+            out.add_tuple("ref_pat_is_mut", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for RefPat {
+    type Label = RefPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ReturnExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ReturnExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ReturnExprTrapLabel> for trap::TrapId<ReturnExpr> {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ReturnExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ReturnExprTrapLabel> for trap::Arg {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct ReturnExpr {
-    pub id: TrapId,
-    pub expr: Option<trap::Label>,
+    pub id: trap::TrapId<ReturnExpr>,
+    pub expr: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for ReturnExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ReturnExpr {
+    fn class_name() -> &'static str { "ReturnExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("return_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("return_exprs", vec![id.into()]);
         if let Some(v) = self.expr {
-            out.add_tuple("return_expr_exprs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("return_expr_exprs", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for ReturnExpr {
+    type Label = ReturnExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct SlicePatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for SlicePatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<SlicePatTrapLabel> for trap::TrapId<SlicePat> {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for SlicePatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<SlicePatTrapLabel> for trap::Arg {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct SlicePat {
-    pub id: TrapId,
-    pub prefix: Vec<trap::Label>,
-    pub slice: Option<trap::Label>,
-    pub suffix: Vec<trap::Label>,
+    pub id: trap::TrapId<SlicePat>,
+    pub prefix: Vec<PatTrapLabel>,
+    pub slice: Option<PatTrapLabel>,
+    pub suffix: Vec<PatTrapLabel>,
 }
 
-impl TrapEntry for SlicePat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for SlicePat {
+    fn class_name() -> &'static str { "SlicePat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("slice_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("slice_pats", vec![id.into()]);
         for (i, v) in self.prefix.into_iter().enumerate() {
-            out.add_tuple("slice_pat_prefixes", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("slice_pat_prefixes", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.slice {
-            out.add_tuple("slice_pat_slice", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("slice_pat_slice", vec![id.into(), v.into()]);
         }
         for (i, v) in self.suffix.into_iter().enumerate() {
-            out.add_tuple("slice_pat_suffixes", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("slice_pat_suffixes", vec![id.into(), i.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for SlicePat {
+    type Label = SlicePatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct TupleExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for TupleExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<TupleExprTrapLabel> for trap::TrapId<TupleExpr> {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for TupleExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<TupleExprTrapLabel> for trap::Arg {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct TupleExpr {
-    pub id: TrapId,
-    pub exprs: Vec<trap::Label>,
+    pub id: trap::TrapId<TupleExpr>,
+    pub exprs: Vec<ExprTrapLabel>,
     pub is_assignee_expr: bool,
 }
 
-impl TrapEntry for TupleExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for TupleExpr {
+    fn class_name() -> &'static str { "TupleExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("tuple_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("tuple_exprs", vec![id.into()]);
         for (i, v) in self.exprs.into_iter().enumerate() {
-            out.add_tuple("tuple_expr_exprs", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("tuple_expr_exprs", vec![id.into(), i.into(), v.into()]);
         }
         if self.is_assignee_expr {
-            out.add_tuple("tuple_expr_is_assignee_expr", vec![trap::Arg::Label(id)]);
+            out.add_tuple("tuple_expr_is_assignee_expr", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for TupleExpr {
+    type Label = TupleExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct TuplePatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for TuplePatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<TuplePatTrapLabel> for trap::TrapId<TuplePat> {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for TuplePatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<TuplePatTrapLabel> for trap::Arg {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct TuplePat {
-    pub id: TrapId,
-    pub args: Vec<trap::Label>,
+    pub id: trap::TrapId<TuplePat>,
+    pub args: Vec<PatTrapLabel>,
     pub ellipsis_index: Option<usize>,
 }
 
-impl TrapEntry for TuplePat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for TuplePat {
+    fn class_name() -> &'static str { "TuplePat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("tuple_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("tuple_pats", vec![id.into()]);
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("tuple_pat_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("tuple_pat_args", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.ellipsis_index {
-            out.add_tuple("tuple_pat_ellipsis_indices", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("tuple_pat_ellipsis_indices", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for TuplePat {
+    type Label = TuplePatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct TupleStructPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for TupleStructPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<TupleStructPatTrapLabel> for trap::TrapId<TupleStructPat> {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for TupleStructPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<TupleStructPatTrapLabel> for trap::Arg {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct TupleStructPat {
-    pub id: TrapId,
-    pub path: Option<trap::Label>,
-    pub args: Vec<trap::Label>,
+    pub id: trap::TrapId<TupleStructPat>,
+    pub path: Option<UnimplementedTrapLabel>,
+    pub args: Vec<PatTrapLabel>,
     pub ellipsis_index: Option<usize>,
 }
 
-impl TrapEntry for TupleStructPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for TupleStructPat {
+    fn class_name() -> &'static str { "TupleStructPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("tuple_struct_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("tuple_struct_pats", vec![id.into()]);
         if let Some(v) = self.path {
-            out.add_tuple("tuple_struct_pat_paths", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("tuple_struct_pat_paths", vec![id.into(), v.into()]);
         }
         for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("tuple_struct_pat_args", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("tuple_struct_pat_args", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.ellipsis_index {
-            out.add_tuple("tuple_struct_pat_ellipsis_indices", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("tuple_struct_pat_ellipsis_indices", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for TupleStructPat {
+    type Label = TupleStructPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct UnaryOpExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for UnaryOpExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<UnaryOpExprTrapLabel> for trap::TrapId<UnaryOpExpr> {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for UnaryOpExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<UnaryOpExprTrapLabel> for trap::Arg {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct UnaryOpExpr {
-    pub id: TrapId,
-    pub expr: trap::Label,
+    pub id: trap::TrapId<UnaryOpExpr>,
+    pub expr: ExprTrapLabel,
     pub op: String,
 }
 
-impl TrapEntry for UnaryOpExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for UnaryOpExpr {
+    fn class_name() -> &'static str { "UnaryOpExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("unary_op_exprs", vec![trap::Arg::Label(id), self.expr.into(), self.op.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("unary_op_exprs", vec![id.into(), self.expr.into(), self.op.into()]);
+    }
+}
+
+impl trap::TrapClass for UnaryOpExpr {
+    type Label = UnaryOpExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct UnderscoreExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for UnderscoreExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<UnderscoreExprTrapLabel> for trap::TrapId<UnderscoreExpr> {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for UnderscoreExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<UnderscoreExprTrapLabel> for trap::Arg {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct UnderscoreExpr {
-    pub id: TrapId,
+    pub id: trap::TrapId<UnderscoreExpr>,
 }
 
-impl TrapEntry for UnderscoreExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for UnderscoreExpr {
+    fn class_name() -> &'static str { "UnderscoreExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("underscore_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("underscore_exprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for UnderscoreExpr {
+    type Label = UnderscoreExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct UnimplementedTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for UnimplementedTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<UnimplementedTrapLabel> for trap::TrapId<Unimplemented> {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for UnimplementedTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<UnimplementedTrapLabel> for trap::Arg {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct Unimplemented {
+    pub id: trap::TrapId<Unimplemented>,
+}
+
+impl trap::TrapEntry for Unimplemented {
+    fn class_name() -> &'static str { "Unimplemented" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("unimplementeds", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Unimplemented {
+    type Label = UnimplementedTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct WildPatTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for WildPatTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<WildPatTrapLabel> for trap::TrapId<WildPat> {
+    fn from(value: WildPatTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for WildPatTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<WildPatTrapLabel> for trap::Arg {
+    fn from(value: WildPatTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct WildPat {
-    pub id: TrapId,
+    pub id: trap::TrapId<WildPat>,
 }
 
-impl TrapEntry for WildPat {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for WildPat {
+    fn class_name() -> &'static str { "WildPat" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("wild_pats", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("wild_pats", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for WildPat {
+    type Label = WildPatTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct YeetExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for YeetExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<YeetExprTrapLabel> for trap::TrapId<YeetExpr> {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for YeetExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<YeetExprTrapLabel> for trap::Arg {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct YeetExpr {
-    pub id: TrapId,
-    pub expr: Option<trap::Label>,
+    pub id: trap::TrapId<YeetExpr>,
+    pub expr: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for YeetExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for YeetExpr {
+    fn class_name() -> &'static str { "YeetExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("yeet_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("yeet_exprs", vec![id.into()]);
         if let Some(v) = self.expr {
-            out.add_tuple("yeet_expr_exprs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("yeet_expr_exprs", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for YeetExpr {
+    type Label = YeetExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct YieldExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for YieldExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<YieldExprTrapLabel> for trap::TrapId<YieldExpr> {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for YieldExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<YieldExprTrapLabel> for trap::Arg {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct YieldExpr {
-    pub id: TrapId,
-    pub expr: Option<trap::Label>,
+    pub id: trap::TrapId<YieldExpr>,
+    pub expr: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for YieldExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for YieldExpr {
+    fn class_name() -> &'static str { "YieldExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("yield_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("yield_exprs", vec![id.into()]);
         if let Some(v) = self.expr {
-            out.add_tuple("yield_expr_exprs", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("yield_expr_exprs", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for YieldExpr {
+    type Label = YieldExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct AsyncBlockExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for AsyncBlockExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<AsyncBlockExprTrapLabel> for trap::TrapId<AsyncBlockExpr> {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for AsyncBlockExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<AsyncBlockExprTrapLabel> for trap::Arg {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct AsyncBlockExpr {
-    pub id: TrapId,
-    pub statements: Vec<trap::Label>,
-    pub tail: Option<trap::Label>,
+    pub id: trap::TrapId<AsyncBlockExpr>,
+    pub statements: Vec<StmtTrapLabel>,
+    pub tail: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for AsyncBlockExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for AsyncBlockExpr {
+    fn class_name() -> &'static str { "AsyncBlockExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("async_block_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("async_block_exprs", vec![id.into()]);
         for (i, v) in self.statements.into_iter().enumerate() {
-            out.add_tuple("block_expr_base_statements", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("block_expr_base_statements", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.tail {
-            out.add_tuple("block_expr_base_tails", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("block_expr_base_tails", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for AsyncBlockExpr {
+    type Label = AsyncBlockExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BlockExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for BlockExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<BlockExprTrapLabel> for trap::TrapId<BlockExpr> {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for BlockExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<BlockExprTrapLabel> for trap::Arg {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct BlockExpr {
-    pub id: TrapId,
-    pub statements: Vec<trap::Label>,
-    pub tail: Option<trap::Label>,
-    pub label: Option<trap::Label>,
+    pub id: trap::TrapId<BlockExpr>,
+    pub statements: Vec<StmtTrapLabel>,
+    pub tail: Option<ExprTrapLabel>,
+    pub label: Option<LabelTrapLabel>,
 }
 
-impl TrapEntry for BlockExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for BlockExpr {
+    fn class_name() -> &'static str { "BlockExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("block_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("block_exprs", vec![id.into()]);
         for (i, v) in self.statements.into_iter().enumerate() {
-            out.add_tuple("block_expr_base_statements", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("block_expr_base_statements", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.tail {
-            out.add_tuple("block_expr_base_tails", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("block_expr_base_tails", vec![id.into(), v.into()]);
         }
         if let Some(v) = self.label {
-            out.add_tuple("block_expr_labels", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("block_expr_labels", vec![id.into(), v.into()]);
         }
     }
 }
 
+impl trap::TrapClass for BlockExpr {
+    type Label = BlockExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ElementListExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for ElementListExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<ElementListExprTrapLabel> for trap::TrapId<ElementListExpr> {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for ElementListExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<ElementListExprTrapLabel> for trap::Arg {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct ElementListExpr {
-    pub id: TrapId,
-    pub elements: Vec<trap::Label>,
+    pub id: trap::TrapId<ElementListExpr>,
+    pub elements: Vec<ExprTrapLabel>,
     pub is_assignee_expr: bool,
 }
 
-impl TrapEntry for ElementListExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for ElementListExpr {
+    fn class_name() -> &'static str { "ElementListExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("element_list_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("element_list_exprs", vec![id.into()]);
         for (i, v) in self.elements.into_iter().enumerate() {
-            out.add_tuple("element_list_expr_elements", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("element_list_expr_elements", vec![id.into(), i.into(), v.into()]);
         }
         if self.is_assignee_expr {
-            out.add_tuple("element_list_expr_is_assignee_expr", vec![trap::Arg::Label(id)]);
+            out.add_tuple("element_list_expr_is_assignee_expr", vec![id.into()]);
         }
     }
 }
 
+impl trap::TrapClass for ElementListExpr {
+    type Label = ElementListExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct RepeatExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for RepeatExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<RepeatExprTrapLabel> for trap::TrapId<RepeatExpr> {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for RepeatExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<RepeatExprTrapLabel> for trap::Arg {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct RepeatExpr {
-    pub id: TrapId,
-    pub initializer: trap::Label,
-    pub repeat: trap::Label,
+    pub id: trap::TrapId<RepeatExpr>,
+    pub initializer: ExprTrapLabel,
+    pub repeat: ExprTrapLabel,
 }
 
-impl TrapEntry for RepeatExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for RepeatExpr {
+    fn class_name() -> &'static str { "RepeatExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("repeat_exprs", vec![trap::Arg::Label(id), self.initializer.into(), self.repeat.into()]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("repeat_exprs", vec![id.into(), self.initializer.into(), self.repeat.into()]);
+    }
+}
+
+impl trap::TrapClass for RepeatExpr {
+    type Label = RepeatExprTrapLabel;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct UnsafeBlockExprTrapLabel(trap::UntypedLabel);
+
+impl From<trap::UntypedLabel> for UnsafeBlockExprTrapLabel {
+    fn from(value: trap::UntypedLabel) -> Self {
+        Self(value)
+    }
+}
+
+impl  From<UnsafeBlockExprTrapLabel> for trap::TrapId<UnsafeBlockExpr> {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        Self::Label(value)
+    }
+}
+
+impl trap::Label for UnsafeBlockExprTrapLabel {
+    fn as_untyped(&self) -> trap::UntypedLabel {
+        self.0
+    }
+}
+
+impl From<UnsafeBlockExprTrapLabel> for trap::Arg {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
     }
 }
 
 #[derive(Debug)]
 pub struct UnsafeBlockExpr {
-    pub id: TrapId,
-    pub statements: Vec<trap::Label>,
-    pub tail: Option<trap::Label>,
+    pub id: trap::TrapId<UnsafeBlockExpr>,
+    pub statements: Vec<StmtTrapLabel>,
+    pub tail: Option<ExprTrapLabel>,
 }
 
-impl TrapEntry for UnsafeBlockExpr {
-    fn extract_id(&mut self) -> TrapId {
-        std::mem::replace(&mut self.id, TrapId::Star)
+impl trap::TrapEntry for UnsafeBlockExpr {
+    fn class_name() -> &'static str { "UnsafeBlockExpr" }
+
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
     }
 
-    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
-        out.add_tuple("unsafe_block_exprs", vec![trap::Arg::Label(id)]);
+    fn emit(self, id: Self::Label, out: &mut trap::Writer) {
+        out.add_tuple("unsafe_block_exprs", vec![id.into()]);
         for (i, v) in self.statements.into_iter().enumerate() {
-            out.add_tuple("block_expr_base_statements", vec![trap::Arg::Label(id), i.into(), v.into()]);
+            out.add_tuple("block_expr_base_statements", vec![id.into(), i.into(), v.into()]);
         }
         if let Some(v) = self.tail {
-            out.add_tuple("block_expr_base_tails", vec![trap::Arg::Label(id), v.into()]);
+            out.add_tuple("block_expr_base_tails", vec![id.into(), v.into()]);
         }
     }
 }
+
+impl trap::TrapClass for UnsafeBlockExpr {
+    type Label = UnsafeBlockExprTrapLabel;
+}
+
+// Conversions
+impl From<LocatableTrapLabel> for ElementTrapLabel {
+    fn from(value: LocatableTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AstNodeTrapLabel> for ElementTrapLabel {
+    fn from(value: AstNodeTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AstNodeTrapLabel> for LocatableTrapLabel {
+    fn from(value: AstNodeTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<DeclarationTrapLabel> for AstNodeTrapLabel {
+    fn from(value: DeclarationTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<DeclarationTrapLabel> for ElementTrapLabel {
+    fn from(value: DeclarationTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<DeclarationTrapLabel> for LocatableTrapLabel {
+    fn from(value: DeclarationTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LabelTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LabelTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LabelTrapLabel> for ElementTrapLabel {
+    fn from(value: LabelTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LabelTrapLabel> for LocatableTrapLabel {
+    fn from(value: LabelTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchArmTrapLabel> for AstNodeTrapLabel {
+    fn from(value: MatchArmTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchArmTrapLabel> for ElementTrapLabel {
+    fn from(value: MatchArmTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchArmTrapLabel> for LocatableTrapLabel {
+    fn from(value: MatchArmTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: PatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PatTrapLabel> for ElementTrapLabel {
+    fn from(value: PatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PatTrapLabel> for LocatableTrapLabel {
+    fn from(value: PatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordFieldPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RecordFieldPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordFieldPatTrapLabel> for ElementTrapLabel {
+    fn from(value: RecordFieldPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordFieldPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: RecordFieldPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitFieldTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RecordLitFieldTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitFieldTrapLabel> for ElementTrapLabel {
+    fn from(value: RecordLitFieldTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitFieldTrapLabel> for LocatableTrapLabel {
+    fn from(value: RecordLitFieldTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<StmtTrapLabel> for AstNodeTrapLabel {
+    fn from(value: StmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<StmtTrapLabel> for ElementTrapLabel {
+    fn from(value: StmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<StmtTrapLabel> for LocatableTrapLabel {
+    fn from(value: StmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TypeRefTrapLabel> for AstNodeTrapLabel {
+    fn from(value: TypeRefTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TypeRefTrapLabel> for ElementTrapLabel {
+    fn from(value: TypeRefTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TypeRefTrapLabel> for LocatableTrapLabel {
+    fn from(value: TypeRefTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ArrayExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ArrayExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ArrayExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ArrayExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ArrayExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AwaitExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AwaitExprTrapLabel> for ElementTrapLabel {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AwaitExprTrapLabel> for ExprTrapLabel {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AwaitExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: AwaitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BecomeExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BecomeExprTrapLabel> for ElementTrapLabel {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BecomeExprTrapLabel> for ExprTrapLabel {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BecomeExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: BecomeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BinaryOpExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BinaryOpExprTrapLabel> for ElementTrapLabel {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BinaryOpExprTrapLabel> for ExprTrapLabel {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BinaryOpExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: BinaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BindPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BindPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BindPatTrapLabel> for ElementTrapLabel {
+    fn from(value: BindPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BindPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: BindPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BindPatTrapLabel> for PatTrapLabel {
+    fn from(value: BindPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprBaseTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprBaseTrapLabel> for ElementTrapLabel {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprBaseTrapLabel> for ExprTrapLabel {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprBaseTrapLabel> for LocatableTrapLabel {
+    fn from(value: BlockExprBaseTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxExprTrapLabel> for ElementTrapLabel {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxExprTrapLabel> for ExprTrapLabel {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: BoxExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxPatTrapLabel> for ElementTrapLabel {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BoxPatTrapLabel> for PatTrapLabel {
+    fn from(value: BoxPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BreakExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BreakExprTrapLabel> for ElementTrapLabel {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BreakExprTrapLabel> for ExprTrapLabel {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BreakExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: BreakExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CallExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: CallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CallExprTrapLabel> for ElementTrapLabel {
+    fn from(value: CallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CallExprTrapLabel> for ExprTrapLabel {
+    fn from(value: CallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CallExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: CallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CastExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: CastExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CastExprTrapLabel> for ElementTrapLabel {
+    fn from(value: CastExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CastExprTrapLabel> for ExprTrapLabel {
+    fn from(value: CastExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<CastExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: CastExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ClosureExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ClosureExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ClosureExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ClosureExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ClosureExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstBlockPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstBlockPatTrapLabel> for ElementTrapLabel {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstBlockPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstBlockPatTrapLabel> for PatTrapLabel {
+    fn from(value: ConstBlockPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ConstExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ConstExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ContinueExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ContinueExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ContinueExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ContinueExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ContinueExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprStmtTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprStmtTrapLabel> for ElementTrapLabel {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprStmtTrapLabel> for LocatableTrapLabel {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ExprStmtTrapLabel> for StmtTrapLabel {
+    fn from(value: ExprStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FieldExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FieldExprTrapLabel> for ElementTrapLabel {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FieldExprTrapLabel> for ExprTrapLabel {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FieldExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: FieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FunctionTrapLabel> for AstNodeTrapLabel {
+    fn from(value: FunctionTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FunctionTrapLabel> for DeclarationTrapLabel {
+    fn from(value: FunctionTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FunctionTrapLabel> for ElementTrapLabel {
+    fn from(value: FunctionTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<FunctionTrapLabel> for LocatableTrapLabel {
+    fn from(value: FunctionTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IfExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: IfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IfExprTrapLabel> for ElementTrapLabel {
+    fn from(value: IfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IfExprTrapLabel> for ExprTrapLabel {
+    fn from(value: IfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IfExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: IfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IndexExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IndexExprTrapLabel> for ElementTrapLabel {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IndexExprTrapLabel> for ExprTrapLabel {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<IndexExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: IndexExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<InlineAsmExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<InlineAsmExprTrapLabel> for ElementTrapLabel {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<InlineAsmExprTrapLabel> for ExprTrapLabel {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<InlineAsmExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: InlineAsmExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ItemStmtTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ItemStmtTrapLabel> for ElementTrapLabel {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ItemStmtTrapLabel> for LocatableTrapLabel {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ItemStmtTrapLabel> for StmtTrapLabel {
+    fn from(value: ItemStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetExprTrapLabel> for ElementTrapLabel {
+    fn from(value: LetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetExprTrapLabel> for ExprTrapLabel {
+    fn from(value: LetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: LetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetStmtTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetStmtTrapLabel> for ElementTrapLabel {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetStmtTrapLabel> for LocatableTrapLabel {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LetStmtTrapLabel> for StmtTrapLabel {
+    fn from(value: LetStmtTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LitPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LitPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LitPatTrapLabel> for ElementTrapLabel {
+    fn from(value: LitPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LitPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: LitPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LitPatTrapLabel> for PatTrapLabel {
+    fn from(value: LitPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LiteralExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LiteralExprTrapLabel> for ElementTrapLabel {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LiteralExprTrapLabel> for ExprTrapLabel {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LiteralExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: LiteralExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LoopExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LoopExprTrapLabel> for ElementTrapLabel {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LoopExprTrapLabel> for ExprTrapLabel {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<LoopExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: LoopExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchExprTrapLabel> for ElementTrapLabel {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchExprTrapLabel> for ExprTrapLabel {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MatchExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: MatchExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MethodCallExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MethodCallExprTrapLabel> for ElementTrapLabel {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MethodCallExprTrapLabel> for ExprTrapLabel {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MethodCallExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: MethodCallExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingExprTrapLabel> for ElementTrapLabel {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingExprTrapLabel> for ExprTrapLabel {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: MissingExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingPatTrapLabel> for ElementTrapLabel {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<MissingPatTrapLabel> for PatTrapLabel {
+    fn from(value: MissingPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ModuleTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ModuleTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ModuleTrapLabel> for DeclarationTrapLabel {
+    fn from(value: ModuleTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ModuleTrapLabel> for ElementTrapLabel {
+    fn from(value: ModuleTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ModuleTrapLabel> for LocatableTrapLabel {
+    fn from(value: ModuleTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OffsetOfExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OffsetOfExprTrapLabel> for ElementTrapLabel {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OffsetOfExprTrapLabel> for ExprTrapLabel {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OffsetOfExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: OffsetOfExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OrPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: OrPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OrPatTrapLabel> for ElementTrapLabel {
+    fn from(value: OrPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OrPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: OrPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<OrPatTrapLabel> for PatTrapLabel {
+    fn from(value: OrPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: PathExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathExprTrapLabel> for ElementTrapLabel {
+    fn from(value: PathExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathExprTrapLabel> for ExprTrapLabel {
+    fn from(value: PathExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: PathExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: PathPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathPatTrapLabel> for ElementTrapLabel {
+    fn from(value: PathPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: PathPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<PathPatTrapLabel> for PatTrapLabel {
+    fn from(value: PathPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangeExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangeExprTrapLabel> for ElementTrapLabel {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangeExprTrapLabel> for ExprTrapLabel {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangeExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: RangeExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangePatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RangePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangePatTrapLabel> for ElementTrapLabel {
+    fn from(value: RangePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangePatTrapLabel> for LocatableTrapLabel {
+    fn from(value: RangePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RangePatTrapLabel> for PatTrapLabel {
+    fn from(value: RangePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitExprTrapLabel> for ElementTrapLabel {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitExprTrapLabel> for ExprTrapLabel {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordLitExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: RecordLitExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordPatTrapLabel> for ElementTrapLabel {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RecordPatTrapLabel> for PatTrapLabel {
+    fn from(value: RecordPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RefExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefExprTrapLabel> for ElementTrapLabel {
+    fn from(value: RefExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefExprTrapLabel> for ExprTrapLabel {
+    fn from(value: RefExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: RefExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RefPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefPatTrapLabel> for ElementTrapLabel {
+    fn from(value: RefPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: RefPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RefPatTrapLabel> for PatTrapLabel {
+    fn from(value: RefPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ReturnExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ReturnExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ReturnExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ReturnExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ReturnExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<SlicePatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<SlicePatTrapLabel> for ElementTrapLabel {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<SlicePatTrapLabel> for LocatableTrapLabel {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<SlicePatTrapLabel> for PatTrapLabel {
+    fn from(value: SlicePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleExprTrapLabel> for ElementTrapLabel {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleExprTrapLabel> for ExprTrapLabel {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: TupleExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TuplePatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TuplePatTrapLabel> for ElementTrapLabel {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TuplePatTrapLabel> for LocatableTrapLabel {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TuplePatTrapLabel> for PatTrapLabel {
+    fn from(value: TuplePatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleStructPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleStructPatTrapLabel> for ElementTrapLabel {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleStructPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<TupleStructPatTrapLabel> for PatTrapLabel {
+    fn from(value: TupleStructPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnaryOpExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnaryOpExprTrapLabel> for ElementTrapLabel {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnaryOpExprTrapLabel> for ExprTrapLabel {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnaryOpExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: UnaryOpExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnderscoreExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnderscoreExprTrapLabel> for ElementTrapLabel {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnderscoreExprTrapLabel> for ExprTrapLabel {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnderscoreExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: UnderscoreExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnimplementedTrapLabel> for AstNodeTrapLabel {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnimplementedTrapLabel> for DeclarationTrapLabel {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnimplementedTrapLabel> for ElementTrapLabel {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnimplementedTrapLabel> for LocatableTrapLabel {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnimplementedTrapLabel> for TypeRefTrapLabel {
+    fn from(value: UnimplementedTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<WildPatTrapLabel> for AstNodeTrapLabel {
+    fn from(value: WildPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<WildPatTrapLabel> for ElementTrapLabel {
+    fn from(value: WildPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<WildPatTrapLabel> for LocatableTrapLabel {
+    fn from(value: WildPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<WildPatTrapLabel> for PatTrapLabel {
+    fn from(value: WildPatTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YeetExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YeetExprTrapLabel> for ElementTrapLabel {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YeetExprTrapLabel> for ExprTrapLabel {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YeetExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: YeetExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YieldExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YieldExprTrapLabel> for ElementTrapLabel {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YieldExprTrapLabel> for ExprTrapLabel {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<YieldExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: YieldExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AsyncBlockExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AsyncBlockExprTrapLabel> for BlockExprBaseTrapLabel {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AsyncBlockExprTrapLabel> for ElementTrapLabel {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AsyncBlockExprTrapLabel> for ExprTrapLabel {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<AsyncBlockExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: AsyncBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprTrapLabel> for BlockExprBaseTrapLabel {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprTrapLabel> for ElementTrapLabel {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprTrapLabel> for ExprTrapLabel {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<BlockExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: BlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ElementListExprTrapLabel> for ArrayExprTrapLabel {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ElementListExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ElementListExprTrapLabel> for ElementTrapLabel {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ElementListExprTrapLabel> for ExprTrapLabel {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<ElementListExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: ElementListExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RepeatExprTrapLabel> for ArrayExprTrapLabel {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RepeatExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RepeatExprTrapLabel> for ElementTrapLabel {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RepeatExprTrapLabel> for ExprTrapLabel {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<RepeatExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: RepeatExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnsafeBlockExprTrapLabel> for AstNodeTrapLabel {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnsafeBlockExprTrapLabel> for BlockExprBaseTrapLabel {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnsafeBlockExprTrapLabel> for ElementTrapLabel {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnsafeBlockExprTrapLabel> for ExprTrapLabel {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
+impl From<UnsafeBlockExprTrapLabel> for LocatableTrapLabel {
+    fn from(value: UnsafeBlockExprTrapLabel) -> Self {
+        value.0.into()
+    }
+}
diff --git a/rust/extractor/src/translate.rs b/rust/extractor/src/translate.rs
index b794a1dd5fb..25922a20aac 100644
--- a/rust/extractor/src/translate.rs
+++ b/rust/extractor/src/translate.rs
@@ -1,5 +1,5 @@
 use crate::archive::Archiver;
-use crate::trap::{AsTrapKeyPart, TrapFile, TrapId};
+use crate::trap::{AsTrapKeyPart, Label, TrapFile, TrapId};
 use crate::{generated, trap_key};
 use codeql_extractor::trap;
 use ra_ap_hir::db::{DefDatabase, InternDatabase};
@@ -71,13 +71,11 @@ impl CrateTranslator<'_> {
         })
     }
 
-    fn emit_location_for_ast_ptr<T>(
+    fn emit_location_for_ast_ptr<L: Label, T: AstNode>(
         &mut self,
-        label: trap::Label,
+        label: L,
         source: ra_ap_hir::InFile<ra_ap_syntax::AstPtr<T>>,
-    ) where
-        T: AstNode,
-    {
+    ) {
         source
             .file_id
             .file_id()
@@ -91,7 +89,7 @@ impl CrateTranslator<'_> {
 
     fn emit_location_for_expr(
         &mut self,
-        label: trap::Label,
+        label: generated::ElementTrapLabel, // TODO: should be ExprTrapLabel
         expr: ra_ap_hir_def::hir::ExprId,
         source_map: &BodySourceMap,
     ) {
@@ -102,7 +100,8 @@ impl CrateTranslator<'_> {
 
     fn emit_location_for_pat(
         &mut self,
-        label: trap::Label,
+        // should be Pat, but we're using for other entities for now
+        label: generated::ElementTrapLabel,
         pat_id: ra_ap_hir_def::hir::PatId,
         source_map: &BodySourceMap,
     ) {
@@ -116,14 +115,16 @@ impl CrateTranslator<'_> {
         pat: &ra_ap_hir_def::hir::LiteralOrConst,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::PatTrapLabel {
         match pat {
             ra_ap_hir_def::hir::LiteralOrConst::Literal(_literal) => {
                 let expr = self.trap.emit(generated::LiteralExpr { id: TrapId::Star });
-                self.trap.emit(generated::LitPat {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::LitPat {
+                        id: TrapId::Star,
+                        expr: expr.into(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::LiteralOrConst::Const(inner) => {
                 self.emit_pat(*inner, body, source_map)
@@ -131,9 +132,9 @@ impl CrateTranslator<'_> {
         }
     }
 
-    fn emit_location_for_label(
+    fn emit_location_for_label<T: Label>(
         &mut self,
-        label: trap::Label,
+        label: T,
         label_id: ra_ap_hir_def::hir::LabelId,
         source_map: &BodySourceMap,
     ) {
@@ -143,7 +144,7 @@ impl CrateTranslator<'_> {
             self.emit_location_for_ast_ptr(label, source)
         }
     }
-    fn emit_location<T: HasSource>(&mut self, label: trap::Label, entity: T)
+    fn emit_location<L: Label, T: HasSource>(&mut self, label: L, entity: T)
     where
         T::Ast: AstNode,
     {
@@ -156,9 +157,9 @@ impl CrateTranslator<'_> {
                 self.emit_location_for_textrange(label, data, range);
             });
     }
-    fn emit_location_for_textrange(
+    fn emit_location_for_textrange<L: Label>(
         &mut self,
-        label: trap::Label,
+        label: L,
         data: FileData,
         range: TextRange,
     ) {
@@ -176,7 +177,7 @@ impl CrateTranslator<'_> {
         label_id: LabelId,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::LabelTrapLabel {
         let label = &body.labels[label_id];
         let ret = self.trap.emit(generated::Label {
             id: TrapId::Star,
@@ -186,11 +187,11 @@ impl CrateTranslator<'_> {
         ret
     }
 
-    fn emit_unimplemented(&mut self) -> trap::Label {
+    fn emit_unimplemented(&mut self) -> generated::UnimplementedTrapLabel {
         self.trap
             .emit(generated::Unimplemented { id: TrapId::Star })
     }
-    fn emit_path(&mut self, _path: &Path) -> trap::Label {
+    fn emit_path(&mut self, _path: &Path) -> generated::UnimplementedTrapLabel {
         self.emit_unimplemented()
     }
 
@@ -199,7 +200,7 @@ impl CrateTranslator<'_> {
         field_pat: &RecordFieldPat,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::RecordFieldPatTrapLabel {
         let RecordFieldPat { name, pat } = field_pat;
         let pat_label = self.emit_pat(*pat, body, source_map);
         let ret = self.trap.emit(generated::RecordFieldPat {
@@ -207,7 +208,7 @@ impl CrateTranslator<'_> {
             name: name.as_str().into(),
             pat: pat_label,
         });
-        self.emit_location_for_pat(ret, *pat, source_map);
+        self.emit_location_for_pat(ret.into(), *pat, source_map);
         ret
     }
 
@@ -216,7 +217,7 @@ impl CrateTranslator<'_> {
         field_expr: &RecordLitField,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::RecordLitFieldTrapLabel {
         let RecordLitField { name, expr } = field_expr;
         let expr_label = self.emit_expr(*expr, body, source_map);
         let ret = self.trap.emit(generated::RecordLitField {
@@ -224,39 +225,51 @@ impl CrateTranslator<'_> {
             name: name.as_str().into(),
             expr: expr_label,
         });
-        self.emit_location_for_expr(ret, *expr, source_map);
+        // TODO find a way for emitting a location for the whole thing
+        self.emit_location_for_expr(ret.into(), *expr, source_map);
         ret
     }
-    fn emit_pat(&mut self, pat_id: PatId, body: &Body, source_map: &BodySourceMap) -> trap::Label {
+    fn emit_pat(
+        &mut self,
+        pat_id: PatId,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> generated::PatTrapLabel {
         let pat = &body.pats[pat_id];
-        let ret = match pat {
-            ra_ap_hir_def::hir::Pat::Missing => {
-                self.trap.emit(generated::MissingPat { id: TrapId::Star })
-            }
-            ra_ap_hir_def::hir::Pat::Wild => {
-                self.trap.emit(generated::WildPat { id: TrapId::Star })
-            }
+        let ret: generated::PatTrapLabel = match pat {
+            ra_ap_hir_def::hir::Pat::Missing => self
+                .trap
+                .emit(generated::MissingPat { id: TrapId::Star })
+                .into(),
+            ra_ap_hir_def::hir::Pat::Wild => self
+                .trap
+                .emit(generated::WildPat { id: TrapId::Star })
+                .into(),
             ra_ap_hir_def::hir::Pat::Tuple { args, ellipsis } => {
                 let args = args
                     .into_iter()
                     .map(|pat| self.emit_pat(*pat, body, source_map))
                     .collect();
                 let ellipsis_index = ellipsis.and_then(|x| x.try_into().ok());
-                self.trap.emit(generated::TuplePat {
-                    id: TrapId::Star,
-                    args,
-                    ellipsis_index,
-                })
+                self.trap
+                    .emit(generated::TuplePat {
+                        id: TrapId::Star,
+                        args,
+                        ellipsis_index,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Or(args) => {
                 let args = args
                     .into_iter()
                     .map(|pat| self.emit_pat(*pat, body, source_map))
                     .collect();
-                self.trap.emit(generated::OrPat {
-                    id: TrapId::Star,
-                    args,
-                })
+                self.trap
+                    .emit(generated::OrPat {
+                        id: TrapId::Star,
+                        args,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Record {
                 path,
@@ -268,12 +281,14 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|arg| self.emit_record_field_pat(arg, body, source_map))
                     .collect();
-                self.trap.emit(generated::RecordPat {
-                    id: TrapId::Star,
-                    path,
-                    args,
-                    has_ellipsis: *ellipsis,
-                })
+                self.trap
+                    .emit(generated::RecordPat {
+                        id: TrapId::Star,
+                        path,
+                        args,
+                        has_ellipsis: *ellipsis,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Range { start, end } => {
                 let start = start
@@ -282,11 +297,13 @@ impl CrateTranslator<'_> {
                 let end = end
                     .as_ref()
                     .map(|x| self.emit_literal_or_const_pat(x, body, source_map));
-                self.trap.emit(generated::RangePat {
-                    id: TrapId::Star,
-                    start,
-                    end,
-                })
+                self.trap
+                    .emit(generated::RangePat {
+                        id: TrapId::Star,
+                        start,
+                        end,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Slice {
                 prefix,
@@ -302,34 +319,42 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|pat| self.emit_pat(*pat, body, source_map))
                     .collect();
-                self.trap.emit(generated::SlicePat {
-                    id: TrapId::Star,
-                    prefix,
-                    slice,
-                    suffix,
-                })
+                self.trap
+                    .emit(generated::SlicePat {
+                        id: TrapId::Star,
+                        prefix,
+                        slice,
+                        suffix,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Path(path) => {
                 let path = self.emit_path(path);
-                self.trap.emit(generated::PathPat {
-                    id: TrapId::Star,
-                    path,
-                })
+                self.trap
+                    .emit(generated::PathPat {
+                        id: TrapId::Star,
+                        path,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Lit(expr) => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::LitPat {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::LitPat {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Bind { id, subpat } => {
                 let subpat = subpat.map(|pat| self.emit_pat(pat, body, source_map));
-                self.trap.emit(generated::BindPat {
-                    id: TrapId::Star,
-                    subpat,
-                    binding_id: body.bindings[*id].name.as_str().into(),
-                })
+                self.trap
+                    .emit(generated::BindPat {
+                        id: TrapId::Star,
+                        subpat,
+                        binding_id: body.bindings[*id].name.as_str().into(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::TupleStruct {
                 path,
@@ -341,48 +366,56 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|arg| self.emit_pat(*arg, body, source_map))
                     .collect();
-                self.trap.emit(generated::TupleStructPat {
-                    id: TrapId::Star,
-                    path,
-                    args,
-                    ellipsis_index: ellipsis.map(|x| x as usize),
-                })
+                self.trap
+                    .emit(generated::TupleStructPat {
+                        id: TrapId::Star,
+                        path,
+                        args,
+                        ellipsis_index: ellipsis.map(|x| x as usize),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Ref { pat, mutability } => {
                 let pat = self.emit_pat(*pat, body, source_map);
-                self.trap.emit(generated::RefPat {
-                    id: TrapId::Star,
-                    pat,
-                    is_mut: mutability.is_mut(),
-                })
+                self.trap
+                    .emit(generated::RefPat {
+                        id: TrapId::Star,
+                        pat,
+                        is_mut: mutability.is_mut(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::Box { inner } => {
                 let inner = self.emit_pat(*inner, body, source_map);
-                self.trap.emit(generated::BoxPat {
-                    id: TrapId::Star,
-                    inner,
-                })
+                self.trap
+                    .emit(generated::BoxPat {
+                        id: TrapId::Star,
+                        inner,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Pat::ConstBlock(expr) => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::ConstBlockPat {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::ConstBlockPat {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
         };
-        self.emit_location_for_pat(ret, pat_id, source_map);
+        self.emit_location_for_pat(ret.into(), pat_id, source_map);
         ret
     }
-    fn emit_type_ref(&mut self, _type_ref: &TypeRef) -> trap::Label {
-        self.emit_unimplemented()
+    fn emit_type_ref(&mut self, _type_ref: &TypeRef) -> generated::TypeRefTrapLabel {
+        self.emit_unimplemented().into()
     }
     fn emit_match_arm(
         &mut self,
         arm: &MatchArm,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::MatchArmTrapLabel {
         let pat = self.emit_pat(arm.pat, body, source_map);
         let guard = arm.guard.map(|g| self.emit_expr(g, body, source_map));
         let expr = self.emit_expr(arm.expr, body, source_map);
@@ -392,7 +425,8 @@ impl CrateTranslator<'_> {
             guard,
             expr,
         });
-        self.emit_location_for_pat(ret, arm.pat, source_map);
+        // TODO find a way to generate a location for the whole match arm
+        self.emit_location_for_pat(ret.into(), arm.pat, source_map);
         ret
     }
     fn emit_stmt(
@@ -400,7 +434,7 @@ impl CrateTranslator<'_> {
         stmt: &Statement,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::StmtTrapLabel {
         match stmt {
             Statement::Let {
                 pat,
@@ -424,8 +458,8 @@ impl CrateTranslator<'_> {
                     else_,
                 });
                 // TODO: find a way to get the location of the entire statement
-                self.emit_location_for_pat(ret, *pat, source_map);
-                ret
+                self.emit_location_for_pat(ret.into(), *pat, source_map);
+                ret.into()
             }
             Statement::Expr { expr, has_semi } => {
                 let expr_label = self.emit_expr(*expr, body, source_map);
@@ -435,10 +469,13 @@ impl CrateTranslator<'_> {
                     has_semicolon: *has_semi,
                 });
                 // TODO: find a way to get the location of the entire statement
-                self.emit_location_for_expr(ret, *expr, source_map);
-                ret
+                self.emit_location_for_expr(ret.into(), *expr, source_map);
+                ret.into()
             }
-            Statement::Item => self.trap.emit(generated::ItemStmt { id: TrapId::Star }),
+            Statement::Item => self
+                .trap
+                .emit(generated::ItemStmt { id: TrapId::Star })
+                .into(),
         }
     }
     fn emit_expr(
@@ -446,18 +483,21 @@ impl CrateTranslator<'_> {
         expr_id: ExprId,
         body: &Body,
         source_map: &BodySourceMap,
-    ) -> trap::Label {
+    ) -> generated::ExprTrapLabel {
         let expr = &body[expr_id];
-        let ret = match expr {
-            ra_ap_hir_def::hir::Expr::Missing => {
-                self.trap.emit(generated::MissingExpr { id: TrapId::Star })
-            }
+        let ret: generated::ExprTrapLabel = match expr {
+            ra_ap_hir_def::hir::Expr::Missing => self
+                .trap
+                .emit(generated::MissingExpr { id: TrapId::Star })
+                .into(),
             ra_ap_hir_def::hir::Expr::Path(path) => {
                 let path = self.emit_path(path);
-                self.trap.emit(generated::PathExpr {
-                    id: TrapId::Star,
-                    path,
-                })
+                self.trap
+                    .emit(generated::PathExpr {
+                        id: TrapId::Star,
+                        path,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::If {
                 condition,
@@ -467,21 +507,25 @@ impl CrateTranslator<'_> {
                 let condition = self.emit_expr(*condition, body, source_map);
                 let then = self.emit_expr(*then_branch, body, source_map);
                 let else_ = else_branch.map(|x| self.emit_expr(x, body, source_map));
-                self.trap.emit(generated::IfExpr {
-                    id: TrapId::Star,
-                    condition,
-                    then,
-                    else_,
-                })
+                self.trap
+                    .emit(generated::IfExpr {
+                        id: TrapId::Star,
+                        condition,
+                        then,
+                        else_,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Let { pat, expr } => {
                 let pat = self.emit_pat(*pat, body, source_map);
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::LetExpr {
-                    id: TrapId::Star,
-                    pat,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::LetExpr {
+                        id: TrapId::Star,
+                        pat,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Block {
                 id: _,
@@ -495,12 +539,14 @@ impl CrateTranslator<'_> {
                     .collect();
                 let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
                 let label = label.map(|l| self.emit_label(l, body, source_map));
-                self.trap.emit(generated::BlockExpr {
-                    id: TrapId::Star,
-                    statements,
-                    tail,
-                    label,
-                })
+                self.trap
+                    .emit(generated::BlockExpr {
+                        id: TrapId::Star,
+                        statements,
+                        tail,
+                        label,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Async {
                 id: _,
@@ -512,19 +558,23 @@ impl CrateTranslator<'_> {
                     .map(|stmt| self.emit_stmt(stmt, body, source_map))
                     .collect();
                 let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
-                self.trap.emit(generated::AsyncBlockExpr {
-                    id: TrapId::Star,
-                    statements,
-                    tail,
-                })
+                self.trap
+                    .emit(generated::AsyncBlockExpr {
+                        id: TrapId::Star,
+                        statements,
+                        tail,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Const(const_block) => {
                 let expr_id = self.db.lookup_intern_anonymous_const(*const_block).root;
                 let expr = self.emit_expr(expr_id, body, source_map);
-                self.trap.emit(generated::ConstExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::ConstExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Unsafe {
                 id: _,
@@ -536,11 +586,13 @@ impl CrateTranslator<'_> {
                     .map(|stmt| self.emit_stmt(stmt, body, source_map))
                     .collect();
                 let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
-                self.trap.emit(generated::UnsafeBlockExpr {
-                    id: TrapId::Star,
-                    statements,
-                    tail,
-                })
+                self.trap
+                    .emit(generated::UnsafeBlockExpr {
+                        id: TrapId::Star,
+                        statements,
+                        tail,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Loop {
                 body: loop_body,
@@ -548,11 +600,13 @@ impl CrateTranslator<'_> {
             } => {
                 let loop_body = self.emit_expr(*loop_body, body, source_map);
                 let label = label.map(|l| self.emit_label(l, body, source_map));
-                self.trap.emit(generated::LoopExpr {
-                    id: TrapId::Star,
-                    body: loop_body,
-                    label,
-                })
+                self.trap
+                    .emit(generated::LoopExpr {
+                        id: TrapId::Star,
+                        body: loop_body,
+                        label,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Call {
                 callee,
@@ -564,12 +618,14 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|e| self.emit_expr(*e, body, source_map))
                     .collect();
-                self.trap.emit(generated::CallExpr {
-                    id: TrapId::Star,
-                    callee,
-                    args,
-                    is_assignee_expr: *is_assignee_expr,
-                })
+                self.trap
+                    .emit(generated::CallExpr {
+                        id: TrapId::Star,
+                        callee,
+                        args,
+                        is_assignee_expr: *is_assignee_expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::MethodCall {
                 receiver,
@@ -583,13 +639,15 @@ impl CrateTranslator<'_> {
                     .map(|e| self.emit_expr(*e, body, source_map))
                     .collect();
                 let generic_args = generic_args.as_ref().map(|_args| self.emit_unimplemented());
-                self.trap.emit(generated::MethodCallExpr {
-                    id: TrapId::Star,
-                    receiver,
-                    method_name: method_name.as_str().into(),
-                    args,
-                    generic_args,
-                })
+                self.trap
+                    .emit(generated::MethodCallExpr {
+                        id: TrapId::Star,
+                        receiver,
+                        method_name: method_name.as_str().into(),
+                        args,
+                        generic_args,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Match { expr, arms } => {
                 let expr = self.emit_expr(*expr, body, source_map);
@@ -598,55 +656,69 @@ impl CrateTranslator<'_> {
                     .map(|e| self.emit_match_arm(e, body, source_map))
                     .collect();
 
-                self.trap.emit(generated::MatchExpr {
-                    id: TrapId::Star,
-                    expr,
-                    branches,
-                })
+                self.trap
+                    .emit(generated::MatchExpr {
+                        id: TrapId::Star,
+                        expr,
+                        branches,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Continue { label } => {
                 let label = label.map(|l| self.emit_label(l, body, source_map));
-                self.trap.emit(generated::ContinueExpr {
-                    id: TrapId::Star,
-                    label,
-                })
+                self.trap
+                    .emit(generated::ContinueExpr {
+                        id: TrapId::Star,
+                        label,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Break { expr, label } => {
                 let expr = expr.map(|e| self.emit_expr(e, body, source_map));
                 let label = label.map(|l| self.emit_label(l, body, source_map));
-                self.trap.emit(generated::BreakExpr {
-                    id: TrapId::Star,
-                    expr,
-                    label,
-                })
+                self.trap
+                    .emit(generated::BreakExpr {
+                        id: TrapId::Star,
+                        expr,
+                        label,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Return { expr } => {
                 let expr = expr.map(|e| self.emit_expr(e, body, source_map));
-                self.trap.emit(generated::ReturnExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::ReturnExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Become { expr } => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::BecomeExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::BecomeExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Yield { expr } => {
                 let expr = expr.map(|e| self.emit_expr(e, body, source_map));
-                self.trap.emit(generated::YieldExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::YieldExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Yeet { expr } => {
                 let expr = expr.map(|e| self.emit_expr(e, body, source_map));
-                self.trap.emit(generated::YeetExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::YeetExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::RecordLit {
                 path, //TODO
@@ -661,38 +733,46 @@ impl CrateTranslator<'_> {
                     .map(|field| self.emit_record_lit_field(field, body, source_map))
                     .collect();
                 let spread = spread.map(|expr_id| self.emit_expr(expr_id, body, source_map));
-                self.trap.emit(generated::RecordLitExpr {
-                    id: TrapId::Star,
-                    path,
-                    fields,
-                    spread,
-                    has_ellipsis: *ellipsis,
-                    is_assignee_expr: *is_assignee_expr,
-                })
+                self.trap
+                    .emit(generated::RecordLitExpr {
+                        id: TrapId::Star,
+                        path,
+                        fields,
+                        spread,
+                        has_ellipsis: *ellipsis,
+                        is_assignee_expr: *is_assignee_expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Field { expr, name } => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::FieldExpr {
-                    id: TrapId::Star,
-                    expr,
-                    name: name.as_str().into(),
-                })
+                self.trap
+                    .emit(generated::FieldExpr {
+                        id: TrapId::Star,
+                        expr,
+                        name: name.as_str().into(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Await { expr } => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::AwaitExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::AwaitExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Cast { expr, type_ref } => {
-                let expr: trap::Label = self.emit_expr(*expr, body, source_map);
-                let type_ref: trap::Label = self.emit_type_ref(type_ref.as_ref());
-                self.trap.emit(generated::CastExpr {
-                    id: TrapId::Star,
-                    expr,
-                    type_ref,
-                })
+                let expr = self.emit_expr(*expr, body, source_map);
+                let type_ref = self.emit_type_ref(type_ref.as_ref());
+                self.trap
+                    .emit(generated::CastExpr {
+                        id: TrapId::Star,
+                        expr,
+                        type_ref,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Ref {
                 expr,
@@ -700,19 +780,23 @@ impl CrateTranslator<'_> {
                 mutability,
             } => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::RefExpr {
-                    id: TrapId::Star,
-                    expr,
-                    is_mut: mutability.is_mut(),
-                    is_raw: rawness.is_raw(),
-                })
+                self.trap
+                    .emit(generated::RefExpr {
+                        id: TrapId::Star,
+                        expr,
+                        is_mut: mutability.is_mut(),
+                        is_raw: rawness.is_raw(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Box { expr } => {
                 let expr = self.emit_expr(*expr, body, source_map);
-                self.trap.emit(generated::BoxExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::BoxExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::UnaryOp { expr, op } => {
                 let expr = self.emit_expr(*expr, body, source_map);
@@ -721,22 +805,26 @@ impl CrateTranslator<'_> {
                     ra_ap_syntax::ast::UnaryOp::Not => "!",
                     ra_ap_syntax::ast::UnaryOp::Neg => "-",
                 };
-                self.trap.emit(generated::UnaryOpExpr {
-                    id: TrapId::Star,
-                    expr,
-                    op: op.into(),
-                })
+                self.trap
+                    .emit(generated::UnaryOpExpr {
+                        id: TrapId::Star,
+                        expr,
+                        op: op.into(),
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::BinaryOp { lhs, rhs, op } => {
                 let lhs = self.emit_expr(*lhs, body, source_map);
                 let rhs = self.emit_expr(*rhs, body, source_map);
                 let op = op.map(|op| format!("{op}"));
-                self.trap.emit(generated::BinaryOpExpr {
-                    id: TrapId::Star,
-                    lhs,
-                    rhs,
-                    op,
-                })
+                self.trap
+                    .emit(generated::BinaryOpExpr {
+                        id: TrapId::Star,
+                        lhs,
+                        rhs,
+                        op,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Range {
                 lhs,
@@ -745,12 +833,14 @@ impl CrateTranslator<'_> {
             } => {
                 let lhs = lhs.map(|lhs| self.emit_expr(lhs, body, source_map));
                 let rhs = rhs.map(|rhs| self.emit_expr(rhs, body, source_map));
-                self.trap.emit(generated::RangeExpr {
-                    id: TrapId::Star,
-                    lhs,
-                    rhs,
-                    is_inclusive: *range_type == RangeOp::Inclusive,
-                })
+                self.trap
+                    .emit(generated::RangeExpr {
+                        id: TrapId::Star,
+                        lhs,
+                        rhs,
+                        is_inclusive: *range_type == RangeOp::Inclusive,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Index {
                 base,
@@ -759,12 +849,14 @@ impl CrateTranslator<'_> {
             } => {
                 let base = self.emit_expr(*base, body, source_map);
                 let index = self.emit_expr(*index, body, source_map);
-                self.trap.emit(generated::IndexExpr {
-                    id: TrapId::Star,
-                    base,
-                    index,
-                    is_assignee_expr: *is_assignee_expr,
-                })
+                self.trap
+                    .emit(generated::IndexExpr {
+                        id: TrapId::Star,
+                        base,
+                        index,
+                        is_assignee_expr: *is_assignee_expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Closure {
                 args,
@@ -790,15 +882,17 @@ impl CrateTranslator<'_> {
                             .map(|arg_type| self.emit_type_ref(arg_type))
                     })
                     .collect();
-                self.trap.emit(generated::ClosureExpr {
-                    id: TrapId::Star,
-                    args,
-                    arg_types,
-                    body: expr,
-                    ret_type,
-                    closure_kind: format!("{:?}", closure_kind),
-                    is_move: *capture_by == CaptureBy::Value,
-                })
+                self.trap
+                    .emit(generated::ClosureExpr {
+                        id: TrapId::Star,
+                        args,
+                        arg_types,
+                        body: expr,
+                        ret_type,
+                        closure_kind: format!("{:?}", closure_kind),
+                        is_move: *capture_by == CaptureBy::Value,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Tuple {
                 exprs,
@@ -808,11 +902,13 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|expr| self.emit_expr(*expr, body, source_map))
                     .collect();
-                self.trap.emit(generated::TupleExpr {
-                    id: TrapId::Star,
-                    exprs,
-                    is_assignee_expr: *is_assignee_expr,
-                })
+                self.trap
+                    .emit(generated::TupleExpr {
+                        id: TrapId::Star,
+                        exprs,
+                        is_assignee_expr: *is_assignee_expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::ElementList {
                 elements,
@@ -822,60 +918,70 @@ impl CrateTranslator<'_> {
                     .into_iter()
                     .map(|expr| self.emit_expr(*expr, body, source_map))
                     .collect();
-                self.trap.emit(generated::ElementListExpr {
-                    id: TrapId::Star,
-                    elements,
-                    is_assignee_expr: *is_assignee_expr,
-                })
+                self.trap
+                    .emit(generated::ElementListExpr {
+                        id: TrapId::Star,
+                        elements,
+                        is_assignee_expr: *is_assignee_expr,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::Repeat {
                 initializer,
                 repeat,
             }) => {
-                let initializer: trap::Label = self.emit_expr(*initializer, body, source_map);
-                let repeat: trap::Label = self.emit_expr(*repeat, body, source_map);
+                let initializer = self.emit_expr(*initializer, body, source_map);
+                let repeat = self.emit_expr(*repeat, body, source_map);
 
-                self.trap.emit(generated::RepeatExpr {
-                    id: TrapId::Star,
-                    initializer,
-                    repeat,
-                })
-            }
-            ra_ap_hir_def::hir::Expr::Literal(_literal) => {
-                self.trap.emit(generated::LiteralExpr { id: TrapId::Star })
+                self.trap
+                    .emit(generated::RepeatExpr {
+                        id: TrapId::Star,
+                        initializer,
+                        repeat,
+                    })
+                    .into()
             }
+            ra_ap_hir_def::hir::Expr::Literal(_literal) => self
+                .trap
+                .emit(generated::LiteralExpr { id: TrapId::Star })
+                .into(),
             ra_ap_hir_def::hir::Expr::Underscore => self
                 .trap
-                .emit(generated::UnderscoreExpr { id: TrapId::Star }),
+                .emit(generated::UnderscoreExpr { id: TrapId::Star })
+                .into(),
             ra_ap_hir_def::hir::Expr::OffsetOf(offset) => {
                 let container = self.emit_type_ref(&offset.container);
                 let fields = offset.fields.iter().map(|x| x.as_str().into()).collect();
-                self.trap.emit(generated::OffsetOfExpr {
-                    id: TrapId::Star,
-                    container,
-                    fields,
-                })
+                self.trap
+                    .emit(generated::OffsetOfExpr {
+                        id: TrapId::Star,
+                        container,
+                        fields,
+                    })
+                    .into()
             }
             ra_ap_hir_def::hir::Expr::InlineAsm(asm) => {
                 let expr = self.emit_expr(asm.e, body, source_map);
-                self.trap.emit(generated::InlineAsmExpr {
-                    id: TrapId::Star,
-                    expr,
-                })
+                self.trap
+                    .emit(generated::InlineAsmExpr {
+                        id: TrapId::Star,
+                        expr,
+                    })
+                    .into()
             }
         };
-        self.emit_location_for_expr(ret, expr_id, source_map);
+        self.emit_location_for_expr(ret.into(), expr_id, source_map);
         ret
     }
 
     fn emit_definition(
         &mut self,
-        module_label: trap::Label,
+        module_label: generated::ModuleTrapLabel,
         id: ModuleDef,
-        labels: &mut Vec<trap::Label>,
+        labels: &mut Vec<generated::DeclarationTrapLabel>,
     ) {
-        let _label = match id {
-            ModuleDef::Module(_) => self.emit_unimplemented(),
+        let label: generated::DeclarationTrapLabel = match id {
+            ModuleDef::Module(_) => self.emit_unimplemented().into(),
             ModuleDef::Function(function) => {
                 let def: ra_ap_hir::DefWithBody = function.into();
 
@@ -887,7 +993,9 @@ impl CrateTranslator<'_> {
                     log::trace!("{}", &txt);
                     self.emit_expr(body.body_expr, &body, &source_map)
                 } else {
-                    self.trap.emit(generated::MissingExpr { id: TrapId::Star })
+                    self.trap
+                        .emit(generated::MissingExpr { id: TrapId::Star })
+                        .into()
                 };
                 let label = self.trap.emit(generated::Function {
                     id: trap_key![module_label, name.as_str()],
@@ -895,57 +1003,54 @@ impl CrateTranslator<'_> {
                     body,
                 });
                 self.emit_location(label, function);
-                // TODO: move this below to add all to module children. For now this causes a
-                // DB inconsistency
-                labels.push(label);
-                label
+                label.into()
             }
             ModuleDef::Adt(adt) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, adt);
-                label
+                label.into()
             }
             ModuleDef::Variant(variant) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, variant);
-                label
+                label.into()
             }
             ModuleDef::Const(const_) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, const_);
-                label
+                label.into()
             }
             ModuleDef::Static(static_) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, static_);
-                label
+                label.into()
             }
             ModuleDef::Trait(trait_) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, trait_);
-                label
+                label.into()
             }
             ModuleDef::TraitAlias(alias) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, alias);
-                label
+                label.into()
             }
             ModuleDef::TypeAlias(type_alias) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, type_alias);
-                label
+                label.into()
             }
-            ModuleDef::BuiltinType(_builtin_type) => self.emit_unimplemented(),
+            ModuleDef::BuiltinType(_builtin_type) => self.emit_unimplemented().into(),
             ModuleDef::Macro(macro_) => {
                 let label = self.emit_unimplemented();
                 self.emit_location(label, macro_);
-                label
+                label.into()
             }
         };
-        //TODO: labels.push(label) for all, not just functions
+        labels.push(label);
     }
 
-    fn emit_module(&mut self, label: trap::Label, module: Module) {
+    fn emit_module(&mut self, label: generated::ModuleTrapLabel, module: Module) {
         let mut children = Vec::new();
         for id in module.declarations(self.db) {
             self.emit_definition(label, id, &mut children);
@@ -958,7 +1063,7 @@ impl CrateTranslator<'_> {
 
     pub fn emit_crate(&mut self) -> std::io::Result<()> {
         self.emit_file(self.krate.root_file(self.db));
-        let mut map = HashMap::<Module, trap::Label>::new();
+        let mut map = HashMap::<Module, generated::ModuleTrapLabel>::new();
         for module in self.krate.modules(self.db) {
             let mut key = String::new();
             if let Some(parent) = module.parent(self.db) {
@@ -975,7 +1080,7 @@ impl CrateTranslator<'_> {
             if let Some(name) = module.name(self.db) {
                 key.push_str(name.as_str());
             }
-            let label = self.trap.label(TrapId::Key(key));
+            let label = self.trap.label(TrapId::<generated::Module>::Key(key));
             map.insert(module, label);
             self.emit_module(label, module);
         }
diff --git a/rust/extractor/src/trap.rs b/rust/extractor/src/trap.rs
index e96e5c5f49d..685ec305589 100644
--- a/rust/extractor/src/trap.rs
+++ b/rust/extractor/src/trap.rs
@@ -5,14 +5,18 @@ use log::debug;
 use ra_ap_ide_db::line_index::LineCol;
 use std::ffi::OsString;
 use std::fmt::Debug;
+use std::hash::Hash;
 use std::path::{Path, PathBuf};
 
+pub use trap::Label as UntypedLabel;
+pub use trap::{Arg, Writer};
+
 //TODO: typed labels
 pub trait AsTrapKeyPart {
     fn as_key_part(&self) -> String;
 }
 
-impl AsTrapKeyPart for trap::Label {
+impl AsTrapKeyPart for UntypedLabel {
     fn as_key_part(&self) -> String {
         format!("{{{}}}", self)
     }
@@ -31,27 +35,27 @@ impl AsTrapKeyPart for &str {
 }
 
 #[derive(Debug, Clone)]
-pub enum TrapId {
+pub enum TrapId<T: TrapEntry> {
     Star,
     Key(String),
-    Label(trap::Label),
+    Label(T::Label),
 }
 
-impl From<String> for TrapId {
+impl<T: TrapEntry> From<String> for TrapId<T> {
     fn from(value: String) -> Self {
         TrapId::Key(value)
     }
 }
 
-impl From<&str> for TrapId {
+impl<T: TrapEntry> From<&str> for TrapId<T> {
     fn from(value: &str) -> Self {
         TrapId::Key(value.into())
     }
 }
 
-impl From<trap::Label> for TrapId {
-    fn from(value: trap::Label) -> Self {
-        TrapId::Label(value)
+impl<T: TrapEntry> From<UntypedLabel> for TrapId<T> {
+    fn from(value: UntypedLabel) -> Self {
+        TrapId::Label(value.into())
     }
 }
 
@@ -66,9 +70,23 @@ macro_rules! trap_key {
     }};
 }
 
-pub trait TrapEntry: std::fmt::Debug {
-    fn extract_id(&mut self) -> TrapId;
-    fn emit(self, id: trap::Label, out: &mut trap::Writer);
+pub trait Label: From<UntypedLabel> + Clone + Debug + Hash + Into<Arg> {
+    fn as_untyped(&self) -> UntypedLabel;
+
+    fn as_key_part(&self) -> String {
+        self.as_untyped().as_key_part()
+    }
+}
+
+pub trait TrapClass {
+    type Label: Label;
+}
+
+pub trait TrapEntry: std::fmt::Debug + TrapClass + Sized {
+    fn class_name() -> &'static str;
+
+    fn extract_id(&mut self) -> TrapId<Self>;
+    fn emit(self, id: Self::Label, out: &mut trap::Writer);
 }
 
 pub struct TrapFile {
@@ -78,10 +96,10 @@ pub struct TrapFile {
 }
 
 impl TrapFile {
-    pub fn emit_location(
+    pub fn emit_location<L: Label>(
         &mut self,
-        file_label: trap::Label,
-        entity_label: trap::Label,
+        file_label: UntypedLabel,
+        entity_label: L,
         start: LineCol,
         end: LineCol,
     ) {
@@ -101,10 +119,7 @@ impl TrapFile {
         );
         self.writer.add_tuple(
             "locatable_locations",
-            vec![
-                trap::Arg::Label(entity_label),
-                trap::Arg::Label(location_label),
-            ],
+            vec![entity_label.into(), location_label.into()],
         );
     }
 
@@ -112,17 +127,21 @@ impl TrapFile {
         extractor::populate_file(&mut self.writer, absolute_path)
     }
 
-    pub fn label(&mut self, id: TrapId) -> trap::Label {
+    pub fn label<T: TrapEntry>(&mut self, id: TrapId<T>) -> T::Label {
         match id {
-            TrapId::Star => self.writer.fresh_id(),
-            TrapId::Key(s) => self.writer.global_id(&s).0,
+            TrapId::Star => self.writer.fresh_id().into(),
+            TrapId::Key(s) => self
+                .writer
+                .global_id(&format!("{},{}", T::class_name(), s))
+                .0
+                .into(),
             TrapId::Label(l) => l,
         }
     }
 
-    pub fn emit<T: TrapEntry>(&mut self, mut e: T) -> trap::Label {
+    pub fn emit<T: TrapEntry>(&mut self, mut e: T) -> T::Label {
         let label = self.label(e.extract_id());
-        e.emit(label, &mut self.writer);
+        e.emit(label.clone(), &mut self.writer);
         label
     }
 
diff --git a/rust/ql/.generated.list b/rust/ql/.generated.list
index cc88ed81504..e2c6c5d7eda 100644
--- a/rust/ql/.generated.list
+++ b/rust/ql/.generated.list
@@ -111,7 +111,6 @@ lib/codeql/rust/elements/TuplePatConstructor.qll 505c4f440b47da576acd7e3fc69d6b4
 lib/codeql/rust/elements/TupleStructPat.qll 50b7d89498dbe6737d97325037156c7689fd8d7e776d66fef9551f173fa3f2d6 f42edcf42be877424ecf2f11c90166a90f485249b24d73ed302294299d6a9bcd
 lib/codeql/rust/elements/TupleStructPatConstructor.qll 15a15362572ac2dc98ed3257f195f20bb8dfe34a1fe203cf2a1a193ce16c406f 9e590b50cf865f6bc573b6fc17acea073f0d9389be241b01e820d9f3f8f14acb
 lib/codeql/rust/elements/TypeRef.qll 223844544eab3e07b6edda805c6344fa8b486aeea7bbe62e4b98e235ce2008d8 7517748b0e7a57c925168f5ce7a31ecc1b59f7521a2095578f599b8d9045a4e5
-lib/codeql/rust/elements/TypeRefConstructor.qll f8b2e5ef15517890a8b2d56643f471ae64cc74c420187049e33b182417e72e4f 683611e732b842756e301a77625b385bca0c4969971020c9e11220a1aa665a29
 lib/codeql/rust/elements/UnaryOpExpr.qll 32e637510c03653cc28cb9a25a2873e9bf346aeb63ad2d7a571bfcbda45c59ce 044b22dd35491f9eafc6488fff5bc929aed12e2f36ac55883925c876978bf7cf
 lib/codeql/rust/elements/UnaryOpExprConstructor.qll 43db7afbd3535b7edc801d99d772233a734f4ed31eeee2ca74e7ab26cae33e87 7345f8d4cb958ee2fa83d3634285f12829bdd1cbac2697236d6fae062313ab6d
 lib/codeql/rust/elements/UnderscoreExpr.qll cd49049149e268524412a17394daaef696ddca63f1f452b369172b9643e94d82 228568c12efc7c055f2ff7cc08c2d0ae150f6356f77ccea98b7f8be3d6bb4806
@@ -171,14 +170,14 @@ lib/codeql/rust/generated/MissingPat.qll 0d8034cee20bacf07ebb9337c797f53a25686a1
 lib/codeql/rust/generated/Module.qll 2a931a4f2cdb2fee00ed83af045ea63d36b7dbd708e58c30445b5610feaae333 cd62add5c31a509f965aa294f44a1607ec7c62e3a9e3fe9ee063b3c814f4eb62
 lib/codeql/rust/generated/OffsetOfExpr.qll 58dfd632efcb48de7fe6ffbcb2192fcf95bfabdb407a751133f63a0e32ae7489 21ebb1b3d66849fc21c04083cfa751eb56c55809cd52664020bd61ccfbe5ea68
 lib/codeql/rust/generated/OrPat.qll f8fe5c7b83a08dabcc530484a696274930040ea13501ae20f1426faeec67bcf0 f3adb3148890531b698570a48740335983a5e81977ba4ac651778f940f184398
-lib/codeql/rust/generated/ParentChild.qll e1658ad4b3406b882726ed623e3668b99d1353c92c22f2939e2b7fc2b4053711 739da3c782d40cbd83c2b1d752376a0363802b64b950bea61e79cfb63bdd4f6d
+lib/codeql/rust/generated/ParentChild.qll f101e2538cd97f54651d995271dda8ecf5d80a204522506b01994a2e37cfac7a 5d1ef956058bb407f3038787b2be2127afdc2a6910a434cce8dd35037c8841a3
 lib/codeql/rust/generated/Pat.qll fe1c72856442dbab5655eff93f86c2cbce8d69d9fa1f99a0f9203061ea1112a4 d85d86e8b6c48df733589d186f610b1cd9086629180701e017774bddc62402c7
 lib/codeql/rust/generated/PathExpr.qll 3664ed2ad08097e4446b0fdad148118c754f8203541ae588d967ba9d79b6bf21 0d987d2358fe9b42e57585e7ae906de80e9f4ccf7c20e1d9bb7624ffbad96941
 lib/codeql/rust/generated/PathPat.qll acc4dda795bae97626a8d0041538f3ba1f0b591c743fed381cf198a8b04653cb c3deee1b3bb9bd37ae3ed4761d8ee2f498384fe5e1f5e31c0f9b99dfd864a0d5
 lib/codeql/rust/generated/PureSynthConstructors.qll 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573
 lib/codeql/rust/generated/RangeExpr.qll f499d8c1f260d6262a55c1f3640aaee832ed8c9aac922cb2e05fefbca4509053 a01563640bc23fbce9d33da756bc209fd16155dc76a7fed4ba325979723f48a5
 lib/codeql/rust/generated/RangePat.qll 6ec95f6cb9c4bd93b38990bb1e3b89b526624305ac6ee7b94e6fb0a2f3db28fc 0e193f3816a7587d5103dba421bc2bf22b869522353d4e3f43d49a792eac6cf4
-lib/codeql/rust/generated/Raw.qll fcc1c9f3b06f7c1ae5ad6f7e7ab508c5fbbe9f13a5888db7e1a1e878d53b0f7e 45b6ee33b3ebe83d7f297eb0a9700da42648dc6228caed1e6649e940ea304907
+lib/codeql/rust/generated/Raw.qll 8d6b4ff602a89f779b15d84885b1d165ab23e9fc8b5953d1dfd3294daf492d8d 04366012c0d1278ed49b753d1d39cf96fbb16f7319072e2ff9714d1ecdd224c3
 lib/codeql/rust/generated/RecordFieldPat.qll 26bed2285d849b9b7ac52d86131eacb40df912db350e423e81fb98c393c08a69 05ed735aecee90901a1bdfae05d9f85d7f6581616eca3a9262fdef6673222f9b
 lib/codeql/rust/generated/RecordLitExpr.qll 1d3264446ff57e8b169f1ad6da150b2d457d6b60eda0ff63e2353eb8ef9e9113 f523dd5ce7f4bac0aafab7b27c6cfe766c72a9ee0c92d7a263347e67edf096df
 lib/codeql/rust/generated/RecordLitField.qll bc704b56a986f3a399dc9c3dc2b61cca0d40cd389c694b9fe13374780835ffcc ab6b05a87f240a97cc2a8c15bb84a1338ad33ce367619125a8514e8815fd050e
@@ -189,15 +188,15 @@ lib/codeql/rust/generated/RepeatExpr.qll 43aff00e966e4550179d756489e4cbc30618d66
 lib/codeql/rust/generated/ReturnExpr.qll 6160f3a14ff1cbd6a297edae015769f90e8e31201639828d8a9d0d6e38c1ef99 b8c8a12f78281e558d230c6959236780758e9645fe22aca697b948535c20f9be
 lib/codeql/rust/generated/SlicePat.qll b4de6692eebf1205940e04da963adc20a07b15923c3c3a7a512a24e3bd8342c9 ee9b919983807f39d97cfe8ca66b76bdbfde76db02db5c93268ce22cbddf4213
 lib/codeql/rust/generated/Stmt.qll 55688c8f42f6e7fd1b871e572d75fac60d0543e38c4be4638abbb00187651d3d f978006a8453137f989249e849a7c935a090da3a9b0116145da80068760e12fd
-lib/codeql/rust/generated/Synth.qll 6d1c4648a7f705bf5d7e8f8081f835c03feb6eee99bbf5fcca825902cb0cac20 620582c3743f8e0172288660bf5b2f344d8696620675ad0a04df20da55ba9c45
-lib/codeql/rust/generated/SynthConstructors.qll 15f62ecc76505a326df6a6d61896892ecbacdd1edc8bb4fede39f1a84e36431e 15f62ecc76505a326df6a6d61896892ecbacdd1edc8bb4fede39f1a84e36431e
+lib/codeql/rust/generated/Synth.qll 98478a5bd0cf16a11b4dc64d4d7d7d4bcd61ee637b29ae59af93938393f804f9 e254397b85bbf3c2254c163f010cc90d08a5c658eed461778e97346e4e60ff2c
+lib/codeql/rust/generated/SynthConstructors.qll 6cfce4c3bfb6c68cf2fa518cf9cadf0fd968219cb97a60be8e471205d459a553 6cfce4c3bfb6c68cf2fa518cf9cadf0fd968219cb97a60be8e471205d459a553
 lib/codeql/rust/generated/TupleExpr.qll 13e4dbc1afcabf388c793145cd399789f4014662f2eed1d49cbe96eeb8355413 bfa0708885c120bad24e29deb29641c69a5e5361654f3a144ead9543bfbd7197
 lib/codeql/rust/generated/TuplePat.qll 23911b2ac7ee2279df8ef40a6e447437ef0ed62518504b17874a7652bf5e3f4b fc4f6f7ea40754290de194ac55939f08549bd637104baf8dc84ca3938bcbd1f1
 lib/codeql/rust/generated/TupleStructPat.qll fff004cce780501eac94fe4b146619a84e02c85cae12ffeba5a4058e8c9738ea 738659f8208aa65d1d8cf601e0d92a90a890d6cbaec51cf04c81fc75a827e30b
-lib/codeql/rust/generated/TypeRef.qll 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533
+lib/codeql/rust/generated/TypeRef.qll 3e8321504060e2e558e6679555e32c8056969806fc367867d4a76f67b9993558 0df712b2e10d366ced1c6518754ba2f56e1a71fc39753234a321c31f46aa3fba
 lib/codeql/rust/generated/UnaryOpExpr.qll fd55d4bc9cd1a49d1f38f02fef16771f29bb5fb2512abd18341d56665859d18c f271ef5036410c018f48d6f15b17cb9beaf4111a42fc638ac4ed3db974a5f870
 lib/codeql/rust/generated/UnderscoreExpr.qll cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d
-lib/codeql/rust/generated/Unimplemented.qll 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113
+lib/codeql/rust/generated/Unimplemented.qll e2b1da6123c7ff71f9ce1133ae2665ac4e1c401084b0eb778aa4ae78cad2d363 e2b1da6123c7ff71f9ce1133ae2665ac4e1c401084b0eb778aa4ae78cad2d363
 lib/codeql/rust/generated/UnsafeBlockExpr.qll 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e
 lib/codeql/rust/generated/WildPat.qll 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8
 lib/codeql/rust/generated/YeetExpr.qll 2b37cf55ec26958cf226885e99d81c8bbc6ece69fbe92d9fcc8884ee0bc4aad4 e371531507311ea8a9fbaac74442fe9994ae85f0acdb79cc870e5318af52aba9
diff --git a/rust/ql/.gitattributes b/rust/ql/.gitattributes
index 7cbeda2ad1b..246e92aee16 100644
--- a/rust/ql/.gitattributes
+++ b/rust/ql/.gitattributes
@@ -113,7 +113,6 @@
 /lib/codeql/rust/elements/TupleStructPat.qll linguist-generated
 /lib/codeql/rust/elements/TupleStructPatConstructor.qll linguist-generated
 /lib/codeql/rust/elements/TypeRef.qll linguist-generated
-/lib/codeql/rust/elements/TypeRefConstructor.qll linguist-generated
 /lib/codeql/rust/elements/UnaryOpExpr.qll linguist-generated
 /lib/codeql/rust/elements/UnaryOpExprConstructor.qll linguist-generated
 /lib/codeql/rust/elements/UnderscoreExpr.qll linguist-generated
diff --git a/rust/ql/lib/codeql/rust/elements/TypeRefConstructor.qll b/rust/ql/lib/codeql/rust/elements/TypeRefConstructor.qll
deleted file mode 100644
index 20b97fae70d..00000000000
--- a/rust/ql/lib/codeql/rust/elements/TypeRefConstructor.qll
+++ /dev/null
@@ -1,14 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- *  This module defines the hook used internally to tweak the characteristic predicate of
- *  `TypeRef` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `TypeRef` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructTypeRef(Raw::TypeRef id) { any() }
diff --git a/rust/ql/lib/codeql/rust/generated/ParentChild.qll b/rust/ql/lib/codeql/rust/generated/ParentChild.qll
index 73b1c76f46f..aa6de7d7082 100644
--- a/rust/ql/lib/codeql/rust/generated/ParentChild.qll
+++ b/rust/ql/lib/codeql/rust/generated/ParentChild.qll
@@ -174,21 +174,6 @@ private module Impl {
     )
   }
 
-  private Element getImmediateChildOfUnimplemented(
-    Unimplemented e, int index, string partialPredicateCall
-  ) {
-    exists(int b, int bAstNode, int n |
-      b = 0 and
-      bAstNode = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfAstNode(e, i, _)) | i) and
-      n = bAstNode and
-      (
-        none()
-        or
-        result = getImmediateChildOfAstNode(e, index - b, partialPredicateCall)
-      )
-    )
-  }
-
   private Element getImmediateChildOfArrayExpr(ArrayExpr e, int index, string partialPredicateCall) {
     exists(int b, int bExpr, int n |
       b = 0 and
@@ -1081,6 +1066,26 @@ private module Impl {
     )
   }
 
+  private Element getImmediateChildOfUnimplemented(
+    Unimplemented e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bDeclaration, int bTypeRef, int n |
+      b = 0 and
+      bDeclaration =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfDeclaration(e, i, _)) | i) and
+      bTypeRef =
+        bDeclaration + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeRef(e, i, _)) | i) and
+      n = bTypeRef and
+      (
+        none()
+        or
+        result = getImmediateChildOfDeclaration(e, index - b, partialPredicateCall)
+        or
+        result = getImmediateChildOfTypeRef(e, index - bDeclaration, partialPredicateCall)
+      )
+    )
+  }
+
   private Element getImmediateChildOfWildPat(WildPat e, int index, string partialPredicateCall) {
     exists(int b, int bPat, int n |
       b = 0 and
@@ -1227,10 +1232,6 @@ private module Impl {
     or
     result = getImmediateChildOfRecordLitField(e, index, partialAccessor)
     or
-    result = getImmediateChildOfTypeRef(e, index, partialAccessor)
-    or
-    result = getImmediateChildOfUnimplemented(e, index, partialAccessor)
-    or
     result = getImmediateChildOfAwaitExpr(e, index, partialAccessor)
     or
     result = getImmediateChildOfBecomeExpr(e, index, partialAccessor)
@@ -1325,6 +1326,8 @@ private module Impl {
     or
     result = getImmediateChildOfUnderscoreExpr(e, index, partialAccessor)
     or
+    result = getImmediateChildOfUnimplemented(e, index, partialAccessor)
+    or
     result = getImmediateChildOfWildPat(e, index, partialAccessor)
     or
     result = getImmediateChildOfYeetExpr(e, index, partialAccessor)
diff --git a/rust/ql/lib/codeql/rust/generated/Raw.qll b/rust/ql/lib/codeql/rust/generated/Raw.qll
index df45ca063ae..44e6bfac08e 100644
--- a/rust/ql/lib/codeql/rust/generated/Raw.qll
+++ b/rust/ql/lib/codeql/rust/generated/Raw.qll
@@ -111,16 +111,7 @@ module Raw {
   /**
    * INTERNAL: Do not use.
    */
-  class TypeRef extends @type_ref, AstNode {
-    override string toString() { result = "TypeRef" }
-  }
-
-  /**
-   * INTERNAL: Do not use.
-   */
-  class Unimplemented extends @unimplemented, AstNode {
-    override string toString() { result = "Unimplemented" }
-  }
+  class TypeRef extends @type_ref, AstNode { }
 
   /**
    * INTERNAL: Do not use.
@@ -931,6 +922,13 @@ module Raw {
     override string toString() { result = "UnderscoreExpr" }
   }
 
+  /**
+   * INTERNAL: Do not use.
+   */
+  class Unimplemented extends @unimplemented, Declaration, TypeRef {
+    override string toString() { result = "Unimplemented" }
+  }
+
   /**
    * INTERNAL: Do not use.
    */
diff --git a/rust/ql/lib/codeql/rust/generated/Synth.qll b/rust/ql/lib/codeql/rust/generated/Synth.qll
index fa4b015ef44..3c860ae05fc 100644
--- a/rust/ql/lib/codeql/rust/generated/Synth.qll
+++ b/rust/ql/lib/codeql/rust/generated/Synth.qll
@@ -227,10 +227,6 @@ module Synth {
      * INTERNAL: Do not use.
      */
     TTupleStructPat(Raw::TupleStructPat id) { constructTupleStructPat(id) } or
-    /**
-     * INTERNAL: Do not use.
-     */
-    TTypeRef(Raw::TypeRef id) { constructTypeRef(id) } or
     /**
      * INTERNAL: Do not use.
      */
@@ -270,7 +266,7 @@ module Synth {
    */
   class TAstNode =
     TDeclaration or TExpr or TLabel or TMatchArm or TPat or TRecordFieldPat or TRecordLitField or
-        TStmt or TTypeRef or TUnimplemented;
+        TStmt or TTypeRef;
 
   /**
    * INTERNAL: Do not use.
@@ -280,7 +276,7 @@ module Synth {
   /**
    * INTERNAL: Do not use.
    */
-  class TDeclaration = TFunction or TModule;
+  class TDeclaration = TFunction or TModule or TUnimplemented;
 
   /**
    * INTERNAL: Do not use.
@@ -310,6 +306,11 @@ module Synth {
    */
   class TStmt = TExprStmt or TItemStmt or TLetStmt;
 
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TTypeRef = TUnimplemented;
+
   /**
    * INTERNAL: Do not use.
    * Converts a raw element to a synthesized `TAsyncBlockExpr`, if possible.
@@ -681,13 +682,6 @@ module Synth {
   cached
   TTupleStructPat convertTupleStructPatFromRaw(Raw::Element e) { result = TTupleStructPat(e) }
 
-  /**
-   * INTERNAL: Do not use.
-   * Converts a raw element to a synthesized `TTypeRef`, if possible.
-   */
-  cached
-  TTypeRef convertTypeRefFromRaw(Raw::Element e) { result = TTypeRef(e) }
-
   /**
    * INTERNAL: Do not use.
    * Converts a raw element to a synthesized `TUnaryOpExpr`, if possible.
@@ -771,8 +765,6 @@ module Synth {
     result = convertStmtFromRaw(e)
     or
     result = convertTypeRefFromRaw(e)
-    or
-    result = convertUnimplementedFromRaw(e)
   }
 
   /**
@@ -797,6 +789,8 @@ module Synth {
     result = convertFunctionFromRaw(e)
     or
     result = convertModuleFromRaw(e)
+    or
+    result = convertUnimplementedFromRaw(e)
   }
 
   /**
@@ -934,6 +928,13 @@ module Synth {
     result = convertLetStmtFromRaw(e)
   }
 
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TTypeRef`, if possible.
+   */
+  cached
+  TTypeRef convertTypeRefFromRaw(Raw::Element e) { result = convertUnimplementedFromRaw(e) }
+
   /**
    * INTERNAL: Do not use.
    * Converts a synthesized `TAsyncBlockExpr` to a raw DB element, if possible.
@@ -1305,13 +1306,6 @@ module Synth {
   cached
   Raw::Element convertTupleStructPatToRaw(TTupleStructPat e) { e = TTupleStructPat(result) }
 
-  /**
-   * INTERNAL: Do not use.
-   * Converts a synthesized `TTypeRef` to a raw DB element, if possible.
-   */
-  cached
-  Raw::Element convertTypeRefToRaw(TTypeRef e) { e = TTypeRef(result) }
-
   /**
    * INTERNAL: Do not use.
    * Converts a synthesized `TUnaryOpExpr` to a raw DB element, if possible.
@@ -1395,8 +1389,6 @@ module Synth {
     result = convertStmtToRaw(e)
     or
     result = convertTypeRefToRaw(e)
-    or
-    result = convertUnimplementedToRaw(e)
   }
 
   /**
@@ -1421,6 +1413,8 @@ module Synth {
     result = convertFunctionToRaw(e)
     or
     result = convertModuleToRaw(e)
+    or
+    result = convertUnimplementedToRaw(e)
   }
 
   /**
@@ -1557,4 +1551,11 @@ module Synth {
     or
     result = convertLetStmtToRaw(e)
   }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeRef` to a raw DB element, if possible.
+   */
+  cached
+  Raw::Element convertTypeRefToRaw(TTypeRef e) { result = convertUnimplementedToRaw(e) }
 }
diff --git a/rust/ql/lib/codeql/rust/generated/SynthConstructors.qll b/rust/ql/lib/codeql/rust/generated/SynthConstructors.qll
index e5a7b47c576..b76c38e56a7 100644
--- a/rust/ql/lib/codeql/rust/generated/SynthConstructors.qll
+++ b/rust/ql/lib/codeql/rust/generated/SynthConstructors.qll
@@ -56,7 +56,6 @@ import codeql.rust.elements.SlicePatConstructor
 import codeql.rust.elements.TupleExprConstructor
 import codeql.rust.elements.TuplePatConstructor
 import codeql.rust.elements.TupleStructPatConstructor
-import codeql.rust.elements.TypeRefConstructor
 import codeql.rust.elements.UnaryOpExprConstructor
 import codeql.rust.elements.UnderscoreExprConstructor
 import codeql.rust.elements.UnimplementedConstructor
diff --git a/rust/ql/lib/codeql/rust/generated/TypeRef.qll b/rust/ql/lib/codeql/rust/generated/TypeRef.qll
index b75359dbbec..cf4f69dc62e 100644
--- a/rust/ql/lib/codeql/rust/generated/TypeRef.qll
+++ b/rust/ql/lib/codeql/rust/generated/TypeRef.qll
@@ -17,7 +17,5 @@ module Generated {
    * INTERNAL: Do not reference the `Generated::TypeRef` class directly.
    * Use the subclass `TypeRef`, where the following predicates are available.
    */
-  class TypeRef extends Synth::TTypeRef, AstNode {
-    override string getAPrimaryQlClass() { result = "TypeRef" }
-  }
+  class TypeRef extends Synth::TTypeRef, AstNode { }
 }
diff --git a/rust/ql/lib/codeql/rust/generated/Unimplemented.qll b/rust/ql/lib/codeql/rust/generated/Unimplemented.qll
index 749c88b8aca..c3e0f9f01a1 100644
--- a/rust/ql/lib/codeql/rust/generated/Unimplemented.qll
+++ b/rust/ql/lib/codeql/rust/generated/Unimplemented.qll
@@ -6,7 +6,8 @@
 
 private import codeql.rust.generated.Synth
 private import codeql.rust.generated.Raw
-import codeql.rust.elements.AstNode
+import codeql.rust.elements.Declaration
+import codeql.rust.elements.TypeRef
 
 /**
  * INTERNAL: This module contains the fully generated definition of `Unimplemented` and should not
@@ -17,7 +18,7 @@ module Generated {
    * INTERNAL: Do not reference the `Generated::Unimplemented` class directly.
    * Use the subclass `Unimplemented`, where the following predicates are available.
    */
-  class Unimplemented extends Synth::TUnimplemented, AstNode {
+  class Unimplemented extends Synth::TUnimplemented, Declaration, TypeRef {
     override string getAPrimaryQlClass() { result = "Unimplemented" }
   }
 }
diff --git a/rust/ql/lib/rust.dbscheme b/rust/ql/lib/rust.dbscheme
index 2aaadbba990..ac9448c2471 100644
--- a/rust/ql/lib/rust.dbscheme
+++ b/rust/ql/lib/rust.dbscheme
@@ -137,12 +137,12 @@ locatable_locations(
 | @record_lit_field
 | @stmt
 | @type_ref
-| @unimplemented
 ;
 
 @declaration =
   @function
 | @module
+| @unimplemented
 ;
 
 @expr =
@@ -233,13 +233,9 @@ record_lit_fields(
 | @let_stmt
 ;
 
-type_refs(
-  unique int id: @type_ref
-);
-
-unimplementeds(
-  unique int id: @unimplemented
-);
+@type_ref =
+  @unimplemented
+;
 
 @array_expr =
   @element_list_expr
@@ -801,6 +797,10 @@ underscore_exprs(
   unique int id: @underscore_expr
 );
 
+unimplementeds(
+  unique int id: @unimplemented
+);
+
 wild_pats(
   unique int id: @wild_pat
 );
diff --git a/rust/schema.py b/rust/schema.py
index d9ea1ca19cb..1249c94b5fb 100644
--- a/rust/schema.py
+++ b/rust/schema.py
@@ -29,11 +29,6 @@ class AstNode(Locatable):
     pass
 
 
-@qltest.skip
-class Unimplemented(AstNode):
-    pass
-
-
 class Declaration(AstNode):
     pass
 
@@ -95,7 +90,7 @@ class MissingExpr(Expr):
 
 
 class PathExpr(Expr):
-    path: Unimplemented | child
+    path: "Unimplemented" | child
 
 #     If {
 #         condition: ExprId,
@@ -196,7 +191,7 @@ class MethodCallExpr(Expr):
     receiver: Expr | child
     method_name: string
     args: list[Expr] | child
-    generic_args: optional[Unimplemented] | child
+    generic_args: optional["Unimplemented"] | child
 
 # pub struct MatchArm {
 #     pub pat: PatId,
@@ -287,7 +282,7 @@ class RecordLitField(AstNode):
 
 
 class RecordLitExpr(Expr):
-    path: optional[Unimplemented] | child
+    path: optional["Unimplemented"] | child
     fields: list[RecordLitField] | child
     spread: optional[Expr] | child
     has_ellipsis: predicate
@@ -514,7 +509,7 @@ class OrPat(Pat):
 
 
 class RecordPat(Pat):
-    path: optional[Unimplemented] | child
+    path: optional["Unimplemented"] | child
     args: list[RecordFieldPat] | child
     has_ellipsis: predicate
 
@@ -535,7 +530,7 @@ class SlicePat(Pat):
 
 
 class PathPat(Pat):
-    path: Unimplemented | child
+    path: "Unimplemented" | child
 
     # Lit(ExprId),
 
@@ -554,7 +549,7 @@ class BindPat(Pat):
 
 
 class TupleStructPat(Pat):
-    path: optional[Unimplemented] | child
+    path: optional["Unimplemented"] | child
     args: list[Pat] | child
     ellipsis_index: optional[int]
 
@@ -575,3 +570,8 @@ class BoxPat(Pat):
 
 class ConstBlockPat(Pat):
     expr: Expr | child
+
+
+@qltest.skip
+class Unimplemented(Declaration, TypeRef):
+    pass