diff --git a/misc/codegen/generators/rustgen.py b/misc/codegen/generators/rustgen.py
index b47e5cc4bd9d..4dd6478df66b 100644
--- a/misc/codegen/generators/rustgen.py
+++ b/misc/codegen/generators/rustgen.py
@@ -101,12 +101,12 @@ def _get_class(self, name: str) -> rust.Class:
         )
 
     def get_classes(self):
-        ret = {"": []}
+        ret = []
         for k, cls in self._classmap.items():
             if not cls.imported and not cls.synth:
-                ret.setdefault(cls.group, []).append(self._get_class(cls.name))
+                ret.append(self._get_class(cls.name))
             elif cls.imported:
-                ret[""].append(rust.Class(name=cls.name))
+                ret.append(rust.Class(name=cls.name))
         return ret
 
 
@@ -114,25 +114,14 @@ def generate(opts, renderer):
     assert opts.rust_output
     processor = Processor(schemaloader.load_file(opts.schema))
     out = opts.rust_output
-    groups = set()
     with renderer.manage(generated=out.rglob("*.rs"),
                          stubs=(),
                          registry=out / ".generated.list",
                          force=opts.force) as renderer:
-        for group, classes in processor.get_classes().items():
-            group = group or "top"
-            groups.add(group)
-            renderer.render(
-                rust.ClassList(
-                    classes,
-                    opts.schema,
-                ),
-                out / f"{group}.rs",
-            )
         renderer.render(
-            rust.ModuleList(
-                groups,
-                opts.schema,
+            rust.ClassList(
+                classes=processor.get_classes(),
+                source=opts.schema,
             ),
             out / f"mod.rs",
         )
diff --git a/misc/codegen/loaders/schemaloader.py b/misc/codegen/loaders/schemaloader.py
index 3b5f20cbbede..5c734279ac80 100644
--- a/misc/codegen/loaders/schemaloader.py
+++ b/misc/codegen/loaders/schemaloader.py
@@ -121,9 +121,14 @@ def _fill_hideable_information(classes: typing.Dict[str, schema.Class]):
 
 
 def _check_test_with(classes: typing.Dict[str, schema.Class]):
+    pragma = "qltest_test_with"
     for cls in classes.values():
-        test_with = typing.cast(str, cls.pragmas.get("qltest_test_with"))
-        transitive_test_with = test_with and classes[test_with].pragmas.get("qltest_test_with")
+        if cls.name == cls.pragmas.get(pragma):
+            # this is already implicit
+            del cls.pragmas[pragma]
+    for cls in classes.values():
+        test_with = typing.cast(str, cls.pragmas.get(pragma))
+        transitive_test_with = test_with and classes[test_with].pragmas.get(pragma)
         if test_with and transitive_test_with:
             raise schema.Error(f"{cls.name} has test_with {test_with} which in turn "
                                f"has test_with {transitive_test_with}, use that directly")
diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs
index 3fe918a4c3eb..4b4c4decdccd 100644
--- a/rust/ast-generator/src/main.rs
+++ b/rust/ast-generator/src/main.rs
@@ -456,7 +456,7 @@ fn write_extractor(grammar: &AstSrc) -> std::io::Result<String> {
 
 use super::base::Translator;
 use super::mappings::TextValue;
-use crate::emit_detached;
+use crate::{{emit_detached,emit_canonical_origin}};
 use crate::generated;
 use crate::trap::{{Label, TrapId}};
 use ra_ap_syntax::ast::{{
diff --git a/rust/extractor/src/generated/.generated.list b/rust/extractor/src/generated/.generated.list
index cbc2dd7c6573..372ccc71a6a6 100644
--- a/rust/extractor/src/generated/.generated.list
+++ b/rust/extractor/src/generated/.generated.list
@@ -1,2 +1 @@
-mod.rs 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7
-top.rs d09cf25daa06fc9bc802e438231e0f038443d2ede3972a0dd829f322b390c4e4 d09cf25daa06fc9bc802e438231e0f038443d2ede3972a0dd829f322b390c4e4
+mod.rs d053373b3e6ec84532b8e8db1358b6f641d023ebdb00341a5f71c7bfe7bfd94d d053373b3e6ec84532b8e8db1358b6f641d023ebdb00341a5f71c7bfe7bfd94d
diff --git a/rust/extractor/src/generated/.gitattributes b/rust/extractor/src/generated/.gitattributes
index 25bb20a99113..e8bb2bee7bc5 100644
--- a/rust/extractor/src/generated/.gitattributes
+++ b/rust/extractor/src/generated/.gitattributes
@@ -1,4 +1,3 @@
 /.generated.list linguist-generated
 /.gitattributes linguist-generated
 /mod.rs linguist-generated
-/top.rs linguist-generated
diff --git a/rust/extractor/src/generated/mod.rs b/rust/extractor/src/generated/mod.rs
index 0f95afeeff20..74d1b91f2d16 100644
--- a/rust/extractor/src/generated/mod.rs
+++ b/rust/extractor/src/generated/mod.rs
@@ -1,4 +1,11494 @@
 // generated by codegen, do not edit
 
-mod top;
-pub use top::*;
+#![cfg_attr(any(), rustfmt::skip)]
+
+use crate::trap;
+
+#[derive(Debug)]
+pub struct File {
+    _unused: ()
+}
+
+impl trap::TrapClass for File {
+    fn class_name() -> &'static str { "File" }
+}
+
+#[derive(Debug)]
+pub struct Element {
+    _unused: ()
+}
+
+impl trap::TrapClass for Element {
+    fn class_name() -> &'static str { "Element" }
+}
+
+#[derive(Debug)]
+pub struct ExtractorStep {
+    pub id: trap::TrapId<ExtractorStep>,
+    pub action: String,
+    pub file: trap::Label<File>,
+    pub duration_ms: usize,
+}
+
+impl trap::TrapEntry for ExtractorStep {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("extractor_steps", vec![id.into(), self.action.into(), self.file.into(), self.duration_ms.into()]);
+    }
+}
+
+impl trap::TrapClass for ExtractorStep {
+    fn class_name() -> &'static str { "ExtractorStep" }
+}
+
+impl From<trap::Label<ExtractorStep>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExtractorStep>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExtractorStep is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Locatable {
+    _unused: ()
+}
+
+impl trap::TrapClass for Locatable {
+    fn class_name() -> &'static str { "Locatable" }
+}
+
+impl From<trap::Label<Locatable>> for trap::Label<Element> {
+    fn from(value: trap::Label<Locatable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Locatable is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Unextracted {
+    _unused: ()
+}
+
+impl trap::TrapClass for Unextracted {
+    fn class_name() -> &'static str { "Unextracted" }
+}
+
+impl From<trap::Label<Unextracted>> for trap::Label<Element> {
+    fn from(value: trap::Label<Unextracted>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Unextracted is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AstNode {
+    _unused: ()
+}
+
+impl trap::TrapClass for AstNode {
+    fn class_name() -> &'static str { "AstNode" }
+}
+
+impl From<trap::Label<AstNode>> for trap::Label<Element> {
+    fn from(value: trap::Label<AstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AstNode>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Missing {
+    pub id: trap::TrapId<Missing>,
+}
+
+impl trap::TrapEntry for Missing {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("missings", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Missing {
+    fn class_name() -> &'static str { "Missing" }
+}
+
+impl From<trap::Label<Missing>> for trap::Label<Element> {
+    fn from(value: trap::Label<Missing>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Missing>> for trap::Label<Unextracted> {
+    fn from(value: trap::Label<Missing>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Unextracted
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Unimplemented {
+    pub id: trap::TrapId<Unimplemented>,
+}
+
+impl trap::TrapEntry for Unimplemented {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("unimplementeds", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for Unimplemented {
+    fn class_name() -> &'static str { "Unimplemented" }
+}
+
+impl From<trap::Label<Unimplemented>> for trap::Label<Element> {
+    fn from(value: trap::Label<Unimplemented>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Unimplemented>> for trap::Label<Unextracted> {
+    fn from(value: trap::Label<Unimplemented>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Unextracted
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Abi {
+    pub id: trap::TrapId<Abi>,
+    pub abi_string: Option<String>,
+}
+
+impl trap::TrapEntry for Abi {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("abis", vec![id.into()]);
+        if let Some(v) = self.abi_string {
+            out.add_tuple("abi_abi_strings", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Abi {
+    fn class_name() -> &'static str { "Abi" }
+}
+
+impl From<trap::Label<Abi>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Abi>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Abi is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Abi>> for trap::Label<Element> {
+    fn from(value: trap::Label<Abi>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Abi>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Abi>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Addressable {
+    _unused: ()
+}
+
+impl Addressable {
+    pub fn emit_canonical_path(id: trap::Label<Self>, value: trap::Label<CanonicalPath>, out: &mut trap::Writer) {
+        out.add_tuple("addressable_canonical_paths", vec![id.into(), value.into()]);
+    }
+}
+
+impl trap::TrapClass for Addressable {
+    fn class_name() -> &'static str { "Addressable" }
+}
+
+impl From<trap::Label<Addressable>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Addressable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Addressable>> for trap::Label<Element> {
+    fn from(value: trap::Label<Addressable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Addressable>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Addressable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ArgList {
+    pub id: trap::TrapId<ArgList>,
+    pub args: Vec<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for ArgList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("arg_lists", vec![id.into()]);
+        for (i, v) in self.args.into_iter().enumerate() {
+            out.add_tuple("arg_list_args", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ArgList {
+    fn class_name() -> &'static str { "ArgList" }
+}
+
+impl From<trap::Label<ArgList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArgList>> for trap::Label<Element> {
+    fn from(value: trap::Label<ArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArgList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AssocItem {
+    _unused: ()
+}
+
+impl trap::TrapClass for AssocItem {
+    fn class_name() -> &'static str { "AssocItem" }
+}
+
+impl From<trap::Label<AssocItem>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<AssocItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocItem>> for trap::Label<Element> {
+    fn from(value: trap::Label<AssocItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocItem>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AssocItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AssocItemList {
+    pub id: trap::TrapId<AssocItemList>,
+    pub assoc_items: Vec<trap::Label<AssocItem>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for AssocItemList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("assoc_item_lists", vec![id.into()]);
+        for (i, v) in self.assoc_items.into_iter().enumerate() {
+            out.add_tuple("assoc_item_list_assoc_items", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("assoc_item_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for AssocItemList {
+    fn class_name() -> &'static str { "AssocItemList" }
+}
+
+impl From<trap::Label<AssocItemList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<AssocItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocItemList>> for trap::Label<Element> {
+    fn from(value: trap::Label<AssocItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocItemList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AssocItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Attr {
+    pub id: trap::TrapId<Attr>,
+    pub meta: Option<trap::Label<Meta>>,
+}
+
+impl trap::TrapEntry for Attr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("attrs", vec![id.into()]);
+        if let Some(v) = self.meta {
+            out.add_tuple("attr_meta", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Attr {
+    fn class_name() -> &'static str { "Attr" }
+}
+
+impl From<trap::Label<Attr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Attr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Attr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Attr>> for trap::Label<Element> {
+    fn from(value: trap::Label<Attr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Attr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Attr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Callable {
+    _unused: ()
+}
+
+impl trap::TrapClass for Callable {
+    fn class_name() -> &'static str { "Callable" }
+}
+
+impl From<trap::Label<Callable>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Callable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Callable is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Callable>> for trap::Label<Element> {
+    fn from(value: trap::Label<Callable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Callable>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Callable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ClosureBinder {
+    pub id: trap::TrapId<ClosureBinder>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+}
+
+impl trap::TrapEntry for ClosureBinder {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("closure_binders", vec![id.into()]);
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("closure_binder_generic_param_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ClosureBinder {
+    fn class_name() -> &'static str { "ClosureBinder" }
+}
+
+impl From<trap::Label<ClosureBinder>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ClosureBinder>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureBinder>> for trap::Label<Element> {
+    fn from(value: trap::Label<ClosureBinder>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureBinder>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ClosureBinder>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Expr {
+    _unused: ()
+}
+
+impl trap::TrapClass for Expr {
+    fn class_name() -> &'static str { "Expr" }
+}
+
+impl From<trap::Label<Expr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Expr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Expr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Expr>> for trap::Label<Element> {
+    fn from(value: trap::Label<Expr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Expr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Expr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExternItem {
+    _unused: ()
+}
+
+impl trap::TrapClass for ExternItem {
+    fn class_name() -> &'static str { "ExternItem" }
+}
+
+impl From<trap::Label<ExternItem>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ExternItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternItem>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExternItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternItem>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ExternItem>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExternItemList {
+    pub id: trap::TrapId<ExternItemList>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub extern_items: Vec<trap::Label<ExternItem>>,
+}
+
+impl trap::TrapEntry for ExternItemList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("extern_item_lists", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("extern_item_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.extern_items.into_iter().enumerate() {
+            out.add_tuple("extern_item_list_extern_items", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ExternItemList {
+    fn class_name() -> &'static str { "ExternItemList" }
+}
+
+impl From<trap::Label<ExternItemList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ExternItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternItemList>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExternItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternItemList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ExternItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FieldList {
+    _unused: ()
+}
+
+impl trap::TrapClass for FieldList {
+    fn class_name() -> &'static str { "FieldList" }
+}
+
+impl From<trap::Label<FieldList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<FieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FieldList>> for trap::Label<Element> {
+    fn from(value: trap::Label<FieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FieldList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<FieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FormatArgsArg {
+    pub id: trap::TrapId<FormatArgsArg>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub name: Option<trap::Label<Name>>,
+}
+
+impl trap::TrapEntry for FormatArgsArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("format_args_args", vec![id.into()]);
+        if let Some(v) = self.expr {
+            out.add_tuple("format_args_arg_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("format_args_arg_names", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for FormatArgsArg {
+    fn class_name() -> &'static str { "FormatArgsArg" }
+}
+
+impl From<trap::Label<FormatArgsArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<FormatArgsArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FormatArgsArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<FormatArgsArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FormatArgsArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<FormatArgsArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GenericArg {
+    _unused: ()
+}
+
+impl trap::TrapClass for GenericArg {
+    fn class_name() -> &'static str { "GenericArg" }
+}
+
+impl From<trap::Label<GenericArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<GenericArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<GenericArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<GenericArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GenericArgList {
+    pub id: trap::TrapId<GenericArgList>,
+    pub generic_args: Vec<trap::Label<GenericArg>>,
+}
+
+impl trap::TrapEntry for GenericArgList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("generic_arg_lists", vec![id.into()]);
+        for (i, v) in self.generic_args.into_iter().enumerate() {
+            out.add_tuple("generic_arg_list_generic_args", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for GenericArgList {
+    fn class_name() -> &'static str { "GenericArgList" }
+}
+
+impl From<trap::Label<GenericArgList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<GenericArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericArgList>> for trap::Label<Element> {
+    fn from(value: trap::Label<GenericArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericArgList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<GenericArgList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GenericParam {
+    _unused: ()
+}
+
+impl trap::TrapClass for GenericParam {
+    fn class_name() -> &'static str { "GenericParam" }
+}
+
+impl From<trap::Label<GenericParam>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<GenericParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericParam>> for trap::Label<Element> {
+    fn from(value: trap::Label<GenericParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericParam>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<GenericParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GenericParamList {
+    pub id: trap::TrapId<GenericParamList>,
+    pub generic_params: Vec<trap::Label<GenericParam>>,
+}
+
+impl trap::TrapEntry for GenericParamList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("generic_param_lists", vec![id.into()]);
+        for (i, v) in self.generic_params.into_iter().enumerate() {
+            out.add_tuple("generic_param_list_generic_params", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for GenericParamList {
+    fn class_name() -> &'static str { "GenericParamList" }
+}
+
+impl From<trap::Label<GenericParamList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<GenericParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericParamList>> for trap::Label<Element> {
+    fn from(value: trap::Label<GenericParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<GenericParamList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<GenericParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ItemList {
+    pub id: trap::TrapId<ItemList>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub items: Vec<trap::Label<Item>>,
+}
+
+impl trap::TrapEntry for ItemList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("item_lists", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("item_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.items.into_iter().enumerate() {
+            out.add_tuple("item_list_items", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ItemList {
+    fn class_name() -> &'static str { "ItemList" }
+}
+
+impl From<trap::Label<ItemList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ItemList>> for trap::Label<Element> {
+    fn from(value: trap::Label<ItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ItemList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ItemList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Label {
+    pub id: trap::TrapId<Label>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+}
+
+impl trap::TrapEntry for Label {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("labels", vec![id.into()]);
+        if let Some(v) = self.lifetime {
+            out.add_tuple("label_lifetimes", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Label {
+    fn class_name() -> &'static str { "Label" }
+}
+
+impl From<trap::Label<Label>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Label>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Label is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Label>> for trap::Label<Element> {
+    fn from(value: trap::Label<Label>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Label is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Label>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Label>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Label is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LetElse {
+    pub id: trap::TrapId<LetElse>,
+    pub block_expr: Option<trap::Label<BlockExpr>>,
+}
+
+impl trap::TrapEntry for LetElse {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("let_elses", vec![id.into()]);
+        if let Some(v) = self.block_expr {
+            out.add_tuple("let_else_block_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LetElse {
+    fn class_name() -> &'static str { "LetElse" }
+}
+
+impl From<trap::Label<LetElse>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LetElse>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetElse>> for trap::Label<Element> {
+    fn from(value: trap::Label<LetElse>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetElse>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LetElse>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Lifetime {
+    pub id: trap::TrapId<Lifetime>,
+    pub text: Option<String>,
+}
+
+impl trap::TrapEntry for Lifetime {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("lifetimes", vec![id.into()]);
+        if let Some(v) = self.text {
+            out.add_tuple("lifetime_texts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Lifetime {
+    fn class_name() -> &'static str { "Lifetime" }
+}
+
+impl From<trap::Label<Lifetime>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Lifetime>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Lifetime>> for trap::Label<Element> {
+    fn from(value: trap::Label<Lifetime>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Lifetime>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Lifetime>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroItems {
+    pub id: trap::TrapId<MacroItems>,
+    pub items: Vec<trap::Label<Item>>,
+}
+
+impl trap::TrapEntry for MacroItems {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_items", vec![id.into()]);
+        for (i, v) in self.items.into_iter().enumerate() {
+            out.add_tuple("macro_items_items", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroItems {
+    fn class_name() -> &'static str { "MacroItems" }
+}
+
+impl From<trap::Label<MacroItems>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroItems>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroItems>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroItems>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroItems>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroItems>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroStmts {
+    pub id: trap::TrapId<MacroStmts>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub statements: Vec<trap::Label<Stmt>>,
+}
+
+impl trap::TrapEntry for MacroStmts {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_stmts", vec![id.into()]);
+        if let Some(v) = self.expr {
+            out.add_tuple("macro_stmts_exprs", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.statements.into_iter().enumerate() {
+            out.add_tuple("macro_stmts_statements", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroStmts {
+    fn class_name() -> &'static str { "MacroStmts" }
+}
+
+impl From<trap::Label<MacroStmts>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroStmts>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroStmts>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroStmts>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroStmts>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroStmts>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MatchArm {
+    pub id: trap::TrapId<MatchArm>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub guard: Option<trap::Label<MatchGuard>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for MatchArm {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("match_arms", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("match_arm_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("match_arm_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.guard {
+            out.add_tuple("match_arm_guards", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("match_arm_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MatchArm {
+    fn class_name() -> &'static str { "MatchArm" }
+}
+
+impl From<trap::Label<MatchArm>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MatchArm>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchArm>> for trap::Label<Element> {
+    fn from(value: trap::Label<MatchArm>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchArm>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MatchArm>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MatchArmList {
+    pub id: trap::TrapId<MatchArmList>,
+    pub arms: Vec<trap::Label<MatchArm>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for MatchArmList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("match_arm_lists", vec![id.into()]);
+        for (i, v) in self.arms.into_iter().enumerate() {
+            out.add_tuple("match_arm_list_arms", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("match_arm_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MatchArmList {
+    fn class_name() -> &'static str { "MatchArmList" }
+}
+
+impl From<trap::Label<MatchArmList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MatchArmList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchArmList>> for trap::Label<Element> {
+    fn from(value: trap::Label<MatchArmList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchArmList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MatchArmList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MatchGuard {
+    pub id: trap::TrapId<MatchGuard>,
+    pub condition: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for MatchGuard {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("match_guards", vec![id.into()]);
+        if let Some(v) = self.condition {
+            out.add_tuple("match_guard_conditions", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MatchGuard {
+    fn class_name() -> &'static str { "MatchGuard" }
+}
+
+impl From<trap::Label<MatchGuard>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MatchGuard>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchGuard>> for trap::Label<Element> {
+    fn from(value: trap::Label<MatchGuard>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchGuard>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MatchGuard>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Meta {
+    pub id: trap::TrapId<Meta>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub is_unsafe: bool,
+    pub path: Option<trap::Label<Path>>,
+    pub token_tree: Option<trap::Label<TokenTree>>,
+}
+
+impl trap::TrapEntry for Meta {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("meta", vec![id.into()]);
+        if let Some(v) = self.expr {
+            out.add_tuple("meta_exprs", vec![id.into(), v.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("meta_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.path {
+            out.add_tuple("meta_paths", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.token_tree {
+            out.add_tuple("meta_token_trees", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Meta {
+    fn class_name() -> &'static str { "Meta" }
+}
+
+impl From<trap::Label<Meta>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Meta>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Meta is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Meta>> for trap::Label<Element> {
+    fn from(value: trap::Label<Meta>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Meta>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Meta>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Name {
+    pub id: trap::TrapId<Name>,
+    pub text: Option<String>,
+}
+
+impl trap::TrapEntry for Name {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("names", vec![id.into()]);
+        if let Some(v) = self.text {
+            out.add_tuple("name_texts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Name {
+    fn class_name() -> &'static str { "Name" }
+}
+
+impl From<trap::Label<Name>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Name>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Name is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Name>> for trap::Label<Element> {
+    fn from(value: trap::Label<Name>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Name is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Name>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Name>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Name is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct NameRef {
+    pub id: trap::TrapId<NameRef>,
+    pub text: Option<String>,
+}
+
+impl trap::TrapEntry for NameRef {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("name_refs", vec![id.into()]);
+        if let Some(v) = self.text {
+            out.add_tuple("name_ref_texts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for NameRef {
+    fn class_name() -> &'static str { "NameRef" }
+}
+
+impl From<trap::Label<NameRef>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<NameRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<NameRef>> for trap::Label<Element> {
+    fn from(value: trap::Label<NameRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<NameRef>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<NameRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParamBase {
+    _unused: ()
+}
+
+impl trap::TrapClass for ParamBase {
+    fn class_name() -> &'static str { "ParamBase" }
+}
+
+impl From<trap::Label<ParamBase>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ParamBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParamBase>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParamBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParamBase>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ParamBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParamList {
+    pub id: trap::TrapId<ParamList>,
+    pub params: Vec<trap::Label<Param>>,
+    pub self_param: Option<trap::Label<SelfParam>>,
+}
+
+impl trap::TrapEntry for ParamList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("param_lists", vec![id.into()]);
+        for (i, v) in self.params.into_iter().enumerate() {
+            out.add_tuple("param_list_params", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.self_param {
+            out.add_tuple("param_list_self_params", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ParamList {
+    fn class_name() -> &'static str { "ParamList" }
+}
+
+impl From<trap::Label<ParamList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParamList>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParamList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ParamList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Pat {
+    _unused: ()
+}
+
+impl trap::TrapClass for Pat {
+    fn class_name() -> &'static str { "Pat" }
+}
+
+impl From<trap::Label<Pat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Pat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Pat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Pat>> for trap::Label<Element> {
+    fn from(value: trap::Label<Pat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Pat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Pat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Path {
+    pub id: trap::TrapId<Path>,
+    pub qualifier: Option<trap::Label<Path>>,
+    pub part: Option<trap::Label<PathSegment>>,
+}
+
+impl trap::TrapEntry for Path {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("paths", vec![id.into()]);
+        if let Some(v) = self.qualifier {
+            out.add_tuple("path_qualifiers", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.part {
+            out.add_tuple("path_parts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Path {
+    fn class_name() -> &'static str { "Path" }
+}
+
+impl From<trap::Label<Path>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Path>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Path is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Path>> for trap::Label<Element> {
+    fn from(value: trap::Label<Path>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Path is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Path>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Path>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Path is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathSegment {
+    pub id: trap::TrapId<PathSegment>,
+    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+    pub param_list: Option<trap::Label<ParamList>>,
+    pub path_type: Option<trap::Label<PathTypeRepr>>,
+    pub ret_type: Option<trap::Label<RetTypeRepr>>,
+    pub return_type_syntax: Option<trap::Label<ReturnTypeSyntax>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for PathSegment {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("path_segments", vec![id.into()]);
+        if let Some(v) = self.generic_arg_list {
+            out.add_tuple("path_segment_generic_arg_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("path_segment_name_refs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.param_list {
+            out.add_tuple("path_segment_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.path_type {
+            out.add_tuple("path_segment_path_types", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.ret_type {
+            out.add_tuple("path_segment_ret_types", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.return_type_syntax {
+            out.add_tuple("path_segment_return_type_syntaxes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("path_segment_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PathSegment {
+    fn class_name() -> &'static str { "PathSegment" }
+}
+
+impl From<trap::Label<PathSegment>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathSegment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathSegment>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathSegment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathSegment>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathSegment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordExprField {
+    pub id: trap::TrapId<RecordExprField>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+}
+
+impl trap::TrapEntry for RecordExprField {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_expr_fields", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("record_expr_field_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("record_expr_field_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("record_expr_field_name_refs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordExprField {
+    fn class_name() -> &'static str { "RecordExprField" }
+}
+
+impl From<trap::Label<RecordExprField>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordExprField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExprField>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordExprField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExprField>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordExprField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordExprFieldList {
+    pub id: trap::TrapId<RecordExprFieldList>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub fields: Vec<trap::Label<RecordExprField>>,
+    pub spread: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for RecordExprFieldList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_expr_field_lists", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("record_expr_field_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("record_expr_field_list_fields", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.spread {
+            out.add_tuple("record_expr_field_list_spreads", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordExprFieldList {
+    fn class_name() -> &'static str { "RecordExprFieldList" }
+}
+
+impl From<trap::Label<RecordExprFieldList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExprFieldList>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExprFieldList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordField {
+    pub id: trap::TrapId<RecordField>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub name: Option<trap::Label<Name>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for RecordField {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_fields", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("record_field_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("record_field_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("record_field_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("record_field_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordField {
+    fn class_name() -> &'static str { "RecordField" }
+}
+
+impl From<trap::Label<RecordField>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordField>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordField>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordPatField {
+    pub id: trap::TrapId<RecordPatField>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for RecordPatField {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_pat_fields", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("record_pat_field_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("record_pat_field_name_refs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("record_pat_field_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordPatField {
+    fn class_name() -> &'static str { "RecordPatField" }
+}
+
+impl From<trap::Label<RecordPatField>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordPatField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPatField>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordPatField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPatField>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordPatField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordPatFieldList {
+    pub id: trap::TrapId<RecordPatFieldList>,
+    pub fields: Vec<trap::Label<RecordPatField>>,
+    pub rest_pat: Option<trap::Label<RestPat>>,
+}
+
+impl trap::TrapEntry for RecordPatFieldList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_pat_field_lists", vec![id.into()]);
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("record_pat_field_list_fields", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.rest_pat {
+            out.add_tuple("record_pat_field_list_rest_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordPatFieldList {
+    fn class_name() -> &'static str { "RecordPatFieldList" }
+}
+
+impl From<trap::Label<RecordPatFieldList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPatFieldList>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPatFieldList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Rename {
+    pub id: trap::TrapId<Rename>,
+    pub name: Option<trap::Label<Name>>,
+}
+
+impl trap::TrapEntry for Rename {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("renames", vec![id.into()]);
+        if let Some(v) = self.name {
+            out.add_tuple("rename_names", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Rename {
+    fn class_name() -> &'static str { "Rename" }
+}
+
+impl From<trap::Label<Rename>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Rename>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Rename is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Rename>> for trap::Label<Element> {
+    fn from(value: trap::Label<Rename>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Rename>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Rename>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Resolvable {
+    _unused: ()
+}
+
+impl Resolvable {
+    pub fn emit_resolved_canonical_path(id: trap::Label<Self>, value: trap::Label<CanonicalPath>, out: &mut trap::Writer) {
+        out.add_tuple("resolvable_resolved_canonical_paths", vec![id.into(), value.into()]);
+    }
+}
+
+impl trap::TrapClass for Resolvable {
+    fn class_name() -> &'static str { "Resolvable" }
+}
+
+impl From<trap::Label<Resolvable>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Resolvable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Resolvable>> for trap::Label<Element> {
+    fn from(value: trap::Label<Resolvable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Resolvable>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Resolvable>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RetTypeRepr {
+    pub id: trap::TrapId<RetTypeRepr>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for RetTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ret_type_reprs", vec![id.into()]);
+        if let Some(v) = self.type_repr {
+            out.add_tuple("ret_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RetTypeRepr {
+    fn class_name() -> &'static str { "RetTypeRepr" }
+}
+
+impl From<trap::Label<RetTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RetTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RetTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<RetTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RetTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RetTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ReturnTypeSyntax {
+    pub id: trap::TrapId<ReturnTypeSyntax>,
+}
+
+impl trap::TrapEntry for ReturnTypeSyntax {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("return_type_syntaxes", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for ReturnTypeSyntax {
+    fn class_name() -> &'static str { "ReturnTypeSyntax" }
+}
+
+impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Element> {
+    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SourceFile {
+    pub id: trap::TrapId<SourceFile>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub items: Vec<trap::Label<Item>>,
+}
+
+impl trap::TrapEntry for SourceFile {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("source_files", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("source_file_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.items.into_iter().enumerate() {
+            out.add_tuple("source_file_items", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for SourceFile {
+    fn class_name() -> &'static str { "SourceFile" }
+}
+
+impl From<trap::Label<SourceFile>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<SourceFile>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SourceFile>> for trap::Label<Element> {
+    fn from(value: trap::Label<SourceFile>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SourceFile>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<SourceFile>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Stmt {
+    _unused: ()
+}
+
+impl trap::TrapClass for Stmt {
+    fn class_name() -> &'static str { "Stmt" }
+}
+
+impl From<trap::Label<Stmt>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Stmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Stmt>> for trap::Label<Element> {
+    fn from(value: trap::Label<Stmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Stmt>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Stmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct StmtList {
+    pub id: trap::TrapId<StmtList>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub statements: Vec<trap::Label<Stmt>>,
+    pub tail_expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for StmtList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("stmt_lists", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("stmt_list_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.statements.into_iter().enumerate() {
+            out.add_tuple("stmt_list_statements", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.tail_expr {
+            out.add_tuple("stmt_list_tail_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for StmtList {
+    fn class_name() -> &'static str { "StmtList" }
+}
+
+impl From<trap::Label<StmtList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<StmtList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<StmtList>> for trap::Label<Element> {
+    fn from(value: trap::Label<StmtList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<StmtList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<StmtList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Token {
+    _unused: ()
+}
+
+impl trap::TrapClass for Token {
+    fn class_name() -> &'static str { "Token" }
+}
+
+impl From<trap::Label<Token>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Token>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Token is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Token>> for trap::Label<Element> {
+    fn from(value: trap::Label<Token>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Token is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Token>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Token>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Token is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TokenTree {
+    pub id: trap::TrapId<TokenTree>,
+}
+
+impl trap::TrapEntry for TokenTree {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("token_trees", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for TokenTree {
+    fn class_name() -> &'static str { "TokenTree" }
+}
+
+impl From<trap::Label<TokenTree>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TokenTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TokenTree>> for trap::Label<Element> {
+    fn from(value: trap::Label<TokenTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TokenTree>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TokenTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TupleField {
+    pub id: trap::TrapId<TupleField>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for TupleField {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_fields", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("tuple_field_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("tuple_field_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("tuple_field_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TupleField {
+    fn class_name() -> &'static str { "TupleField" }
+}
+
+impl From<trap::Label<TupleField>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TupleField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleField>> for trap::Label<Element> {
+    fn from(value: trap::Label<TupleField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleField>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TupleField>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeBound {
+    pub id: trap::TrapId<TypeBound>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub is_async: bool,
+    pub is_const: bool,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for TypeBound {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_bounds", vec![id.into()]);
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("type_bound_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_async {
+            out.add_tuple("type_bound_is_async", vec![id.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("type_bound_is_const", vec![id.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("type_bound_lifetimes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("type_bound_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TypeBound {
+    fn class_name() -> &'static str { "TypeBound" }
+}
+
+impl From<trap::Label<TypeBound>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeBound>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeBound>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeBound>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeBound>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeBound>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeBoundList {
+    pub id: trap::TrapId<TypeBoundList>,
+    pub bounds: Vec<trap::Label<TypeBound>>,
+}
+
+impl trap::TrapEntry for TypeBoundList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_bound_lists", vec![id.into()]);
+        for (i, v) in self.bounds.into_iter().enumerate() {
+            out.add_tuple("type_bound_list_bounds", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TypeBoundList {
+    fn class_name() -> &'static str { "TypeBoundList" }
+}
+
+impl From<trap::Label<TypeBoundList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeBoundList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeBoundList>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeBoundList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeBoundList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeBoundList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeRepr {
+    _unused: ()
+}
+
+impl trap::TrapClass for TypeRepr {
+    fn class_name() -> &'static str { "TypeRepr" }
+}
+
+impl From<trap::Label<TypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UseTree {
+    pub id: trap::TrapId<UseTree>,
+    pub path: Option<trap::Label<Path>>,
+    pub rename: Option<trap::Label<Rename>>,
+    pub use_tree_list: Option<trap::Label<UseTreeList>>,
+}
+
+impl trap::TrapEntry for UseTree {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("use_trees", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("use_tree_paths", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.rename {
+            out.add_tuple("use_tree_renames", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.use_tree_list {
+            out.add_tuple("use_tree_use_tree_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for UseTree {
+    fn class_name() -> &'static str { "UseTree" }
+}
+
+impl From<trap::Label<UseTree>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<UseTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UseTree>> for trap::Label<Element> {
+    fn from(value: trap::Label<UseTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UseTree>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<UseTree>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UseTreeList {
+    pub id: trap::TrapId<UseTreeList>,
+    pub use_trees: Vec<trap::Label<UseTree>>,
+}
+
+impl trap::TrapEntry for UseTreeList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("use_tree_lists", vec![id.into()]);
+        for (i, v) in self.use_trees.into_iter().enumerate() {
+            out.add_tuple("use_tree_list_use_trees", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for UseTreeList {
+    fn class_name() -> &'static str { "UseTreeList" }
+}
+
+impl From<trap::Label<UseTreeList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<UseTreeList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UseTreeList>> for trap::Label<Element> {
+    fn from(value: trap::Label<UseTreeList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UseTreeList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<UseTreeList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct VariantList {
+    pub id: trap::TrapId<VariantList>,
+    pub variants: Vec<trap::Label<Variant>>,
+}
+
+impl trap::TrapEntry for VariantList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("variant_lists", vec![id.into()]);
+        for (i, v) in self.variants.into_iter().enumerate() {
+            out.add_tuple("variant_list_variants", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for VariantList {
+    fn class_name() -> &'static str { "VariantList" }
+}
+
+impl From<trap::Label<VariantList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<VariantList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<VariantList>> for trap::Label<Element> {
+    fn from(value: trap::Label<VariantList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<VariantList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<VariantList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Visibility {
+    pub id: trap::TrapId<Visibility>,
+    pub path: Option<trap::Label<Path>>,
+}
+
+impl trap::TrapEntry for Visibility {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("visibilities", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("visibility_paths", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Visibility {
+    fn class_name() -> &'static str { "Visibility" }
+}
+
+impl From<trap::Label<Visibility>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Visibility>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Visibility>> for trap::Label<Element> {
+    fn from(value: trap::Label<Visibility>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Visibility>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Visibility>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WhereClause {
+    pub id: trap::TrapId<WhereClause>,
+    pub predicates: Vec<trap::Label<WherePred>>,
+}
+
+impl trap::TrapEntry for WhereClause {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("where_clauses", vec![id.into()]);
+        for (i, v) in self.predicates.into_iter().enumerate() {
+            out.add_tuple("where_clause_predicates", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for WhereClause {
+    fn class_name() -> &'static str { "WhereClause" }
+}
+
+impl From<trap::Label<WhereClause>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<WhereClause>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhereClause>> for trap::Label<Element> {
+    fn from(value: trap::Label<WhereClause>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhereClause>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<WhereClause>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WherePred {
+    pub id: trap::TrapId<WherePred>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for WherePred {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("where_preds", vec![id.into()]);
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("where_pred_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("where_pred_lifetimes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("where_pred_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("where_pred_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for WherePred {
+    fn class_name() -> &'static str { "WherePred" }
+}
+
+impl From<trap::Label<WherePred>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<WherePred>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WherePred>> for trap::Label<Element> {
+    fn from(value: trap::Label<WherePred>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WherePred>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<WherePred>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ArrayExprInternal {
+    pub id: trap::TrapId<ArrayExprInternal>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub exprs: Vec<trap::Label<Expr>>,
+    pub is_semicolon: bool,
+}
+
+impl trap::TrapEntry for ArrayExprInternal {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("array_expr_internals", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("array_expr_internal_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.exprs.into_iter().enumerate() {
+            out.add_tuple("array_expr_internal_exprs", vec![id.into(), i.into(), v.into()]);
+        }
+        if self.is_semicolon {
+            out.add_tuple("array_expr_internal_is_semicolon", vec![id.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ArrayExprInternal {
+    fn class_name() -> &'static str { "ArrayExprInternal" }
+}
+
+impl From<trap::Label<ArrayExprInternal>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayExprInternal>> for trap::Label<Element> {
+    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayExprInternal>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayExprInternal>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ArrayTypeRepr {
+    pub id: trap::TrapId<ArrayTypeRepr>,
+    pub const_arg: Option<trap::Label<ConstArg>>,
+    pub element_type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for ArrayTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("array_type_reprs", vec![id.into()]);
+        if let Some(v) = self.const_arg {
+            out.add_tuple("array_type_repr_const_args", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.element_type_repr {
+            out.add_tuple("array_type_repr_element_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ArrayTypeRepr {
+    fn class_name() -> &'static str { "ArrayTypeRepr" }
+}
+
+impl From<trap::Label<ArrayTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ArrayTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AsmExpr {
+    pub id: trap::TrapId<AsmExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for AsmExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("asm_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("asm_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("asm_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for AsmExpr {
+    fn class_name() -> &'static str { "AsmExpr" }
+}
+
+impl From<trap::Label<AsmExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<AsmExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AsmExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<AsmExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AsmExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<AsmExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AsmExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AsmExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AssocTypeArg {
+    pub id: trap::TrapId<AssocTypeArg>,
+    pub const_arg: Option<trap::Label<ConstArg>>,
+    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+    pub param_list: Option<trap::Label<ParamList>>,
+    pub ret_type: Option<trap::Label<RetTypeRepr>>,
+    pub return_type_syntax: Option<trap::Label<ReturnTypeSyntax>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for AssocTypeArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("assoc_type_args", vec![id.into()]);
+        if let Some(v) = self.const_arg {
+            out.add_tuple("assoc_type_arg_const_args", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_arg_list {
+            out.add_tuple("assoc_type_arg_generic_arg_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("assoc_type_arg_name_refs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.param_list {
+            out.add_tuple("assoc_type_arg_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.ret_type {
+            out.add_tuple("assoc_type_arg_ret_types", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.return_type_syntax {
+            out.add_tuple("assoc_type_arg_return_type_syntaxes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("assoc_type_arg_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("assoc_type_arg_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for AssocTypeArg {
+    fn class_name() -> &'static str { "AssocTypeArg" }
+}
+
+impl From<trap::Label<AssocTypeArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<AssocTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocTypeArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<AssocTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocTypeArg>> for trap::Label<GenericArg> {
+    fn from(value: trap::Label<AssocTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of GenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AssocTypeArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AssocTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AwaitExpr {
+    pub id: trap::TrapId<AwaitExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for AwaitExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("await_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("await_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("await_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for AwaitExpr {
+    fn class_name() -> &'static str { "AwaitExpr" }
+}
+
+impl From<trap::Label<AwaitExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<AwaitExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AwaitExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<AwaitExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AwaitExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<AwaitExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<AwaitExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<AwaitExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BecomeExpr {
+    pub id: trap::TrapId<BecomeExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for BecomeExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("become_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("become_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("become_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for BecomeExpr {
+    fn class_name() -> &'static str { "BecomeExpr" }
+}
+
+impl From<trap::Label<BecomeExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<BecomeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BecomeExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<BecomeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BecomeExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<BecomeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BecomeExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<BecomeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BinaryExpr {
+    pub id: trap::TrapId<BinaryExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub lhs: Option<trap::Label<Expr>>,
+    pub operator_name: Option<String>,
+    pub rhs: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for BinaryExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("binary_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("binary_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.lhs {
+            out.add_tuple("binary_expr_lhs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.operator_name {
+            out.add_tuple("binary_expr_operator_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.rhs {
+            out.add_tuple("binary_expr_rhs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for BinaryExpr {
+    fn class_name() -> &'static str { "BinaryExpr" }
+}
+
+impl From<trap::Label<BinaryExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<BinaryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BinaryExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<BinaryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BinaryExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<BinaryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BinaryExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<BinaryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BoxPat {
+    pub id: trap::TrapId<BoxPat>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for BoxPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("box_pats", vec![id.into()]);
+        if let Some(v) = self.pat {
+            out.add_tuple("box_pat_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for BoxPat {
+    fn class_name() -> &'static str { "BoxPat" }
+}
+
+impl From<trap::Label<BoxPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<BoxPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BoxPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<BoxPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BoxPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<BoxPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BoxPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<BoxPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BreakExpr {
+    pub id: trap::TrapId<BreakExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+}
+
+impl trap::TrapEntry for BreakExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("break_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("break_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("break_expr_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("break_expr_lifetimes", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for BreakExpr {
+    fn class_name() -> &'static str { "BreakExpr" }
+}
+
+impl From<trap::Label<BreakExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<BreakExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BreakExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<BreakExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BreakExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<BreakExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BreakExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<BreakExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CallExprBase {
+    _unused: ()
+}
+
+impl trap::TrapClass for CallExprBase {
+    fn class_name() -> &'static str { "CallExprBase" }
+}
+
+impl From<trap::Label<CallExprBase>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<CallExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExprBase>> for trap::Label<Element> {
+    fn from(value: trap::Label<CallExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExprBase>> for trap::Label<Expr> {
+    fn from(value: trap::Label<CallExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExprBase>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<CallExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CastExpr {
+    pub id: trap::TrapId<CastExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for CastExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("cast_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("cast_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("cast_expr_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("cast_expr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for CastExpr {
+    fn class_name() -> &'static str { "CastExpr" }
+}
+
+impl From<trap::Label<CastExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<CastExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CastExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<CastExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CastExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<CastExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CastExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<CastExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ClosureExpr {
+    pub id: trap::TrapId<ClosureExpr>,
+    pub param_list: Option<trap::Label<ParamList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub body: Option<trap::Label<Expr>>,
+    pub closure_binder: Option<trap::Label<ClosureBinder>>,
+    pub is_async: bool,
+    pub is_const: bool,
+    pub is_gen: bool,
+    pub is_move: bool,
+    pub is_static: bool,
+    pub ret_type: Option<trap::Label<RetTypeRepr>>,
+}
+
+impl trap::TrapEntry for ClosureExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("closure_exprs", vec![id.into()]);
+        if let Some(v) = self.param_list {
+            out.add_tuple("callable_param_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("callable_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.body {
+            out.add_tuple("closure_expr_bodies", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.closure_binder {
+            out.add_tuple("closure_expr_closure_binders", vec![id.into(), v.into()]);
+        }
+        if self.is_async {
+            out.add_tuple("closure_expr_is_async", vec![id.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("closure_expr_is_const", vec![id.into()]);
+        }
+        if self.is_gen {
+            out.add_tuple("closure_expr_is_gen", vec![id.into()]);
+        }
+        if self.is_move {
+            out.add_tuple("closure_expr_is_move", vec![id.into()]);
+        }
+        if self.is_static {
+            out.add_tuple("closure_expr_is_static", vec![id.into()]);
+        }
+        if let Some(v) = self.ret_type {
+            out.add_tuple("closure_expr_ret_types", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ClosureExpr {
+    fn class_name() -> &'static str { "ClosureExpr" }
+}
+
+impl From<trap::Label<ClosureExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ClosureExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureExpr>> for trap::Label<Callable> {
+    fn from(value: trap::Label<ClosureExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Callable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ClosureExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ClosureExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ClosureExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ClosureExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Comment {
+    pub id: trap::TrapId<Comment>,
+    pub parent: trap::Label<AstNode>,
+    pub text: String,
+}
+
+impl trap::TrapEntry for Comment {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("comments", vec![id.into(), self.parent.into(), self.text.into()]);
+    }
+}
+
+impl trap::TrapClass for Comment {
+    fn class_name() -> &'static str { "Comment" }
+}
+
+impl From<trap::Label<Comment>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Comment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Comment>> for trap::Label<Element> {
+    fn from(value: trap::Label<Comment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Comment>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Comment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Comment>> for trap::Label<Token> {
+    fn from(value: trap::Label<Comment>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Token
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConstArg {
+    pub id: trap::TrapId<ConstArg>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for ConstArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("const_args", vec![id.into()]);
+        if let Some(v) = self.expr {
+            out.add_tuple("const_arg_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ConstArg {
+    fn class_name() -> &'static str { "ConstArg" }
+}
+
+impl From<trap::Label<ConstArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ConstArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<ConstArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstArg>> for trap::Label<GenericArg> {
+    fn from(value: trap::Label<ConstArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of GenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ConstArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConstBlockPat {
+    pub id: trap::TrapId<ConstBlockPat>,
+    pub block_expr: Option<trap::Label<BlockExpr>>,
+    pub is_const: bool,
+}
+
+impl trap::TrapEntry for ConstBlockPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("const_block_pats", vec![id.into()]);
+        if let Some(v) = self.block_expr {
+            out.add_tuple("const_block_pat_block_exprs", vec![id.into(), v.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("const_block_pat_is_const", vec![id.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ConstBlockPat {
+    fn class_name() -> &'static str { "ConstBlockPat" }
+}
+
+impl From<trap::Label<ConstBlockPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ConstBlockPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstBlockPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<ConstBlockPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstBlockPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ConstBlockPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstBlockPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<ConstBlockPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConstParam {
+    pub id: trap::TrapId<ConstParam>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub default_val: Option<trap::Label<ConstArg>>,
+    pub is_const: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for ConstParam {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("const_params", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("const_param_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.default_val {
+            out.add_tuple("const_param_default_vals", vec![id.into(), v.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("const_param_is_const", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("const_param_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("const_param_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ConstParam {
+    fn class_name() -> &'static str { "ConstParam" }
+}
+
+impl From<trap::Label<ConstParam>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ConstParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstParam>> for trap::Label<Element> {
+    fn from(value: trap::Label<ConstParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstParam>> for trap::Label<GenericParam> {
+    fn from(value: trap::Label<ConstParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of GenericParam
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstParam>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ConstParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ContinueExpr {
+    pub id: trap::TrapId<ContinueExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+}
+
+impl trap::TrapEntry for ContinueExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("continue_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("continue_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("continue_expr_lifetimes", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ContinueExpr {
+    fn class_name() -> &'static str { "ContinueExpr" }
+}
+
+impl From<trap::Label<ContinueExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ContinueExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ContinueExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ContinueExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ContinueExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ContinueExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ContinueExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ContinueExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct DynTraitTypeRepr {
+    pub id: trap::TrapId<DynTraitTypeRepr>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for DynTraitTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("dyn_trait_type_reprs", vec![id.into()]);
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("dyn_trait_type_repr_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for DynTraitTypeRepr {
+    fn class_name() -> &'static str { "DynTraitTypeRepr" }
+}
+
+impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExprStmt {
+    pub id: trap::TrapId<ExprStmt>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for ExprStmt {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("expr_stmts", vec![id.into()]);
+        if let Some(v) = self.expr {
+            out.add_tuple("expr_stmt_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ExprStmt {
+    fn class_name() -> &'static str { "ExprStmt" }
+}
+
+impl From<trap::Label<ExprStmt>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ExprStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExprStmt>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExprStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExprStmt>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ExprStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExprStmt>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<ExprStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FieldExpr {
+    pub id: trap::TrapId<FieldExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+}
+
+impl trap::TrapEntry for FieldExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("field_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("field_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("field_expr_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("field_expr_name_refs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for FieldExpr {
+    fn class_name() -> &'static str { "FieldExpr" }
+}
+
+impl From<trap::Label<FieldExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<FieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FieldExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<FieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FieldExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<FieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FieldExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<FieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FnPtrTypeRepr {
+    pub id: trap::TrapId<FnPtrTypeRepr>,
+    pub abi: Option<trap::Label<Abi>>,
+    pub is_async: bool,
+    pub is_const: bool,
+    pub is_unsafe: bool,
+    pub param_list: Option<trap::Label<ParamList>>,
+    pub ret_type: Option<trap::Label<RetTypeRepr>>,
+}
+
+impl trap::TrapEntry for FnPtrTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("fn_ptr_type_reprs", vec![id.into()]);
+        if let Some(v) = self.abi {
+            out.add_tuple("fn_ptr_type_repr_abis", vec![id.into(), v.into()]);
+        }
+        if self.is_async {
+            out.add_tuple("fn_ptr_type_repr_is_async", vec![id.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("fn_ptr_type_repr_is_const", vec![id.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("fn_ptr_type_repr_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.param_list {
+            out.add_tuple("fn_ptr_type_repr_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.ret_type {
+            out.add_tuple("fn_ptr_type_repr_ret_types", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for FnPtrTypeRepr {
+    fn class_name() -> &'static str { "FnPtrTypeRepr" }
+}
+
+impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ForTypeRepr {
+    pub id: trap::TrapId<ForTypeRepr>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for ForTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("for_type_reprs", vec![id.into()]);
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("for_type_repr_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("for_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ForTypeRepr {
+    fn class_name() -> &'static str { "ForTypeRepr" }
+}
+
+impl From<trap::Label<ForTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ForTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ForTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ForTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<ForTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FormatArgsExpr {
+    pub id: trap::TrapId<FormatArgsExpr>,
+    pub args: Vec<trap::Label<FormatArgsArg>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub template: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for FormatArgsExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("format_args_exprs", vec![id.into()]);
+        for (i, v) in self.args.into_iter().enumerate() {
+            out.add_tuple("format_args_expr_args", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("format_args_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.template {
+            out.add_tuple("format_args_expr_templates", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for FormatArgsExpr {
+    fn class_name() -> &'static str { "FormatArgsExpr" }
+}
+
+impl From<trap::Label<FormatArgsExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FormatArgsExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FormatArgsExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<FormatArgsExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct IdentPat {
+    pub id: trap::TrapId<IdentPat>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub is_mut: bool,
+    pub is_ref: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for IdentPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ident_pats", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("ident_pat_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if self.is_mut {
+            out.add_tuple("ident_pat_is_mut", vec![id.into()]);
+        }
+        if self.is_ref {
+            out.add_tuple("ident_pat_is_ref", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("ident_pat_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("ident_pat_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for IdentPat {
+    fn class_name() -> &'static str { "IdentPat" }
+}
+
+impl From<trap::Label<IdentPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<IdentPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IdentPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<IdentPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IdentPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<IdentPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IdentPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<IdentPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct IfExpr {
+    pub id: trap::TrapId<IfExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub condition: Option<trap::Label<Expr>>,
+    pub else_: Option<trap::Label<Expr>>,
+    pub then: Option<trap::Label<BlockExpr>>,
+}
+
+impl trap::TrapEntry for IfExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("if_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("if_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.condition {
+            out.add_tuple("if_expr_conditions", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.else_ {
+            out.add_tuple("if_expr_elses", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.then {
+            out.add_tuple("if_expr_thens", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for IfExpr {
+    fn class_name() -> &'static str { "IfExpr" }
+}
+
+impl From<trap::Label<IfExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<IfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IfExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<IfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IfExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<IfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IfExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<IfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ImplTraitTypeRepr {
+    pub id: trap::TrapId<ImplTraitTypeRepr>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for ImplTraitTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("impl_trait_type_reprs", vec![id.into()]);
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("impl_trait_type_repr_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ImplTraitTypeRepr {
+    fn class_name() -> &'static str { "ImplTraitTypeRepr" }
+}
+
+impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct IndexExpr {
+    pub id: trap::TrapId<IndexExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub base: Option<trap::Label<Expr>>,
+    pub index: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for IndexExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("index_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("index_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.base {
+            out.add_tuple("index_expr_bases", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.index {
+            out.add_tuple("index_expr_indices", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for IndexExpr {
+    fn class_name() -> &'static str { "IndexExpr" }
+}
+
+impl From<trap::Label<IndexExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<IndexExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IndexExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<IndexExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IndexExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<IndexExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<IndexExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<IndexExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct InferTypeRepr {
+    pub id: trap::TrapId<InferTypeRepr>,
+}
+
+impl trap::TrapEntry for InferTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("infer_type_reprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for InferTypeRepr {
+    fn class_name() -> &'static str { "InferTypeRepr" }
+}
+
+impl From<trap::Label<InferTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<InferTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<InferTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<InferTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<InferTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<InferTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<InferTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<InferTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Item {
+    _unused: ()
+}
+
+impl trap::TrapClass for Item {
+    fn class_name() -> &'static str { "Item" }
+}
+
+impl From<trap::Label<Item>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Item>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Item>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Item>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Item>> for trap::Label<Element> {
+    fn from(value: trap::Label<Item>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Item>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Item>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Item>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Item>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LabelableExpr {
+    _unused: ()
+}
+
+impl trap::TrapClass for LabelableExpr {
+    fn class_name() -> &'static str { "LabelableExpr" }
+}
+
+impl From<trap::Label<LabelableExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LabelableExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LabelableExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<LabelableExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LabelableExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<LabelableExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LabelableExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LabelableExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LetExpr {
+    pub id: trap::TrapId<LetExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub scrutinee: Option<trap::Label<Expr>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for LetExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("let_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("let_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.scrutinee {
+            out.add_tuple("let_expr_scrutinees", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("let_expr_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LetExpr {
+    fn class_name() -> &'static str { "LetExpr" }
+}
+
+impl From<trap::Label<LetExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<LetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<LetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LetStmt {
+    pub id: trap::TrapId<LetStmt>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub initializer: Option<trap::Label<Expr>>,
+    pub let_else: Option<trap::Label<LetElse>>,
+    pub pat: Option<trap::Label<Pat>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for LetStmt {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("let_stmts", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("let_stmt_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.initializer {
+            out.add_tuple("let_stmt_initializers", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.let_else {
+            out.add_tuple("let_stmt_let_elses", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("let_stmt_pats", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("let_stmt_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LetStmt {
+    fn class_name() -> &'static str { "LetStmt" }
+}
+
+impl From<trap::Label<LetStmt>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LetStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetStmt>> for trap::Label<Element> {
+    fn from(value: trap::Label<LetStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetStmt>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LetStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LetStmt>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<LetStmt>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LifetimeArg {
+    pub id: trap::TrapId<LifetimeArg>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+}
+
+impl trap::TrapEntry for LifetimeArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("lifetime_args", vec![id.into()]);
+        if let Some(v) = self.lifetime {
+            out.add_tuple("lifetime_arg_lifetimes", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LifetimeArg {
+    fn class_name() -> &'static str { "LifetimeArg" }
+}
+
+impl From<trap::Label<LifetimeArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LifetimeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<LifetimeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeArg>> for trap::Label<GenericArg> {
+    fn from(value: trap::Label<LifetimeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of GenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LifetimeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LifetimeParam {
+    pub id: trap::TrapId<LifetimeParam>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for LifetimeParam {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("lifetime_params", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("lifetime_param_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("lifetime_param_lifetimes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("lifetime_param_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LifetimeParam {
+    fn class_name() -> &'static str { "LifetimeParam" }
+}
+
+impl From<trap::Label<LifetimeParam>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LifetimeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeParam>> for trap::Label<Element> {
+    fn from(value: trap::Label<LifetimeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeParam>> for trap::Label<GenericParam> {
+    fn from(value: trap::Label<LifetimeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of GenericParam
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LifetimeParam>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LifetimeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LiteralExpr {
+    pub id: trap::TrapId<LiteralExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub text_value: Option<String>,
+}
+
+impl trap::TrapEntry for LiteralExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("literal_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("literal_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.text_value {
+            out.add_tuple("literal_expr_text_values", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LiteralExpr {
+    fn class_name() -> &'static str { "LiteralExpr" }
+}
+
+impl From<trap::Label<LiteralExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LiteralExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<LiteralExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<LiteralExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LiteralExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LiteralPat {
+    pub id: trap::TrapId<LiteralPat>,
+    pub literal: Option<trap::Label<LiteralExpr>>,
+}
+
+impl trap::TrapEntry for LiteralPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("literal_pats", vec![id.into()]);
+        if let Some(v) = self.literal {
+            out.add_tuple("literal_pat_literals", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LiteralPat {
+    fn class_name() -> &'static str { "LiteralPat" }
+}
+
+impl From<trap::Label<LiteralPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LiteralPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<LiteralPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LiteralPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LiteralPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<LiteralPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroExpr {
+    pub id: trap::TrapId<MacroExpr>,
+    pub macro_call: Option<trap::Label<MacroCall>>,
+}
+
+impl trap::TrapEntry for MacroExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_exprs", vec![id.into()]);
+        if let Some(v) = self.macro_call {
+            out.add_tuple("macro_expr_macro_calls", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroExpr {
+    fn class_name() -> &'static str { "MacroExpr" }
+}
+
+impl From<trap::Label<MacroExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<MacroExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroPat {
+    pub id: trap::TrapId<MacroPat>,
+    pub macro_call: Option<trap::Label<MacroCall>>,
+}
+
+impl trap::TrapEntry for MacroPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_pats", vec![id.into()]);
+        if let Some(v) = self.macro_call {
+            out.add_tuple("macro_pat_macro_calls", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroPat {
+    fn class_name() -> &'static str { "MacroPat" }
+}
+
+impl From<trap::Label<MacroPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<MacroPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroTypeRepr {
+    pub id: trap::TrapId<MacroTypeRepr>,
+    pub macro_call: Option<trap::Label<MacroCall>>,
+}
+
+impl trap::TrapEntry for MacroTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_type_reprs", vec![id.into()]);
+        if let Some(v) = self.macro_call {
+            out.add_tuple("macro_type_repr_macro_calls", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroTypeRepr {
+    fn class_name() -> &'static str { "MacroTypeRepr" }
+}
+
+impl From<trap::Label<MacroTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MatchExpr {
+    pub id: trap::TrapId<MatchExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub scrutinee: Option<trap::Label<Expr>>,
+    pub match_arm_list: Option<trap::Label<MatchArmList>>,
+}
+
+impl trap::TrapEntry for MatchExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("match_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("match_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.scrutinee {
+            out.add_tuple("match_expr_scrutinees", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.match_arm_list {
+            out.add_tuple("match_expr_match_arm_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MatchExpr {
+    fn class_name() -> &'static str { "MatchExpr" }
+}
+
+impl From<trap::Label<MatchExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MatchExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<MatchExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<MatchExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MatchExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MatchExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct NeverTypeRepr {
+    pub id: trap::TrapId<NeverTypeRepr>,
+}
+
+impl trap::TrapEntry for NeverTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("never_type_reprs", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for NeverTypeRepr {
+    fn class_name() -> &'static str { "NeverTypeRepr" }
+}
+
+impl From<trap::Label<NeverTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<NeverTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<NeverTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<NeverTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct OffsetOfExpr {
+    pub id: trap::TrapId<OffsetOfExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub fields: Vec<trap::Label<NameRef>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for OffsetOfExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("offset_of_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("offset_of_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("offset_of_expr_fields", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("offset_of_expr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for OffsetOfExpr {
+    fn class_name() -> &'static str { "OffsetOfExpr" }
+}
+
+impl From<trap::Label<OffsetOfExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OffsetOfExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OffsetOfExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OffsetOfExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct OrPat {
+    pub id: trap::TrapId<OrPat>,
+    pub pats: Vec<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for OrPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("or_pats", vec![id.into()]);
+        for (i, v) in self.pats.into_iter().enumerate() {
+            out.add_tuple("or_pat_pats", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for OrPat {
+    fn class_name() -> &'static str { "OrPat" }
+}
+
+impl From<trap::Label<OrPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<OrPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OrPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<OrPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OrPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<OrPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<OrPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<OrPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Param {
+    pub id: trap::TrapId<Param>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for Param {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("params", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("param_base_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("param_base_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("param_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Param {
+    fn class_name() -> &'static str { "Param" }
+}
+
+impl From<trap::Label<Param>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Param>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Param>> for trap::Label<Element> {
+    fn from(value: trap::Label<Param>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Param>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Param>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Param>> for trap::Label<ParamBase> {
+    fn from(value: trap::Label<Param>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of ParamBase
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParenExpr {
+    pub id: trap::TrapId<ParenExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for ParenExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("paren_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("paren_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("paren_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ParenExpr {
+    fn class_name() -> &'static str { "ParenExpr" }
+}
+
+impl From<trap::Label<ParenExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ParenExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParenExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ParenExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ParenExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParenPat {
+    pub id: trap::TrapId<ParenPat>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for ParenPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("paren_pats", vec![id.into()]);
+        if let Some(v) = self.pat {
+            out.add_tuple("paren_pat_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ParenPat {
+    fn class_name() -> &'static str { "ParenPat" }
+}
+
+impl From<trap::Label<ParenPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ParenPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParenPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ParenPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<ParenPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParenTypeRepr {
+    pub id: trap::TrapId<ParenTypeRepr>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for ParenTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("paren_type_reprs", vec![id.into()]);
+        if let Some(v) = self.type_repr {
+            out.add_tuple("paren_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ParenTypeRepr {
+    fn class_name() -> &'static str { "ParenTypeRepr" }
+}
+
+impl From<trap::Label<ParenTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParenTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathAstNode {
+    _unused: ()
+}
+
+impl trap::TrapClass for PathAstNode {
+    fn class_name() -> &'static str { "PathAstNode" }
+}
+
+impl From<trap::Label<PathAstNode>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathAstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathAstNode>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathAstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathAstNode>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathAstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathAstNode>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<PathAstNode>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathExprBase {
+    _unused: ()
+}
+
+impl trap::TrapClass for PathExprBase {
+    fn class_name() -> &'static str { "PathExprBase" }
+}
+
+impl From<trap::Label<PathExprBase>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExprBase>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExprBase>> for trap::Label<Expr> {
+    fn from(value: trap::Label<PathExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExprBase>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathExprBase>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathTypeRepr {
+    pub id: trap::TrapId<PathTypeRepr>,
+    pub path: Option<trap::Label<Path>>,
+}
+
+impl trap::TrapEntry for PathTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("path_type_reprs", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_type_repr_paths", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PathTypeRepr {
+    fn class_name() -> &'static str { "PathTypeRepr" }
+}
+
+impl From<trap::Label<PathTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<PathTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PrefixExpr {
+    pub id: trap::TrapId<PrefixExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub operator_name: Option<String>,
+}
+
+impl trap::TrapEntry for PrefixExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("prefix_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("prefix_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("prefix_expr_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.operator_name {
+            out.add_tuple("prefix_expr_operator_names", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PrefixExpr {
+    fn class_name() -> &'static str { "PrefixExpr" }
+}
+
+impl From<trap::Label<PrefixExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PrefixExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PrefixExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<PrefixExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PrefixExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<PrefixExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PrefixExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PrefixExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PtrTypeRepr {
+    pub id: trap::TrapId<PtrTypeRepr>,
+    pub is_const: bool,
+    pub is_mut: bool,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for PtrTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ptr_type_reprs", vec![id.into()]);
+        if self.is_const {
+            out.add_tuple("ptr_type_repr_is_const", vec![id.into()]);
+        }
+        if self.is_mut {
+            out.add_tuple("ptr_type_repr_is_mut", vec![id.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("ptr_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PtrTypeRepr {
+    fn class_name() -> &'static str { "PtrTypeRepr" }
+}
+
+impl From<trap::Label<PtrTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PtrTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PtrTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PtrTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RangeExpr {
+    pub id: trap::TrapId<RangeExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub end: Option<trap::Label<Expr>>,
+    pub operator_name: Option<String>,
+    pub start: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for RangeExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("range_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("range_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.end {
+            out.add_tuple("range_expr_ends", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.operator_name {
+            out.add_tuple("range_expr_operator_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.start {
+            out.add_tuple("range_expr_starts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RangeExpr {
+    fn class_name() -> &'static str { "RangeExpr" }
+}
+
+impl From<trap::Label<RangeExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RangeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangeExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<RangeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangeExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<RangeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangeExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RangeExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RangePat {
+    pub id: trap::TrapId<RangePat>,
+    pub end: Option<trap::Label<Pat>>,
+    pub operator_name: Option<String>,
+    pub start: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for RangePat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("range_pats", vec![id.into()]);
+        if let Some(v) = self.end {
+            out.add_tuple("range_pat_ends", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.operator_name {
+            out.add_tuple("range_pat_operator_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.start {
+            out.add_tuple("range_pat_starts", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RangePat {
+    fn class_name() -> &'static str { "RangePat" }
+}
+
+impl From<trap::Label<RangePat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RangePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangePat>> for trap::Label<Element> {
+    fn from(value: trap::Label<RangePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangePat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RangePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RangePat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<RangePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordFieldList {
+    pub id: trap::TrapId<RecordFieldList>,
+    pub fields: Vec<trap::Label<RecordField>>,
+}
+
+impl trap::TrapEntry for RecordFieldList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_field_lists", vec![id.into()]);
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("record_field_list_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordFieldList {
+    fn class_name() -> &'static str { "RecordFieldList" }
+}
+
+impl From<trap::Label<RecordFieldList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordFieldList>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordFieldList>> for trap::Label<FieldList> {
+    fn from(value: trap::Label<RecordFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of FieldList
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordFieldList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RefExpr {
+    pub id: trap::TrapId<RefExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub is_const: bool,
+    pub is_mut: bool,
+    pub is_raw: bool,
+}
+
+impl trap::TrapEntry for RefExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ref_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("ref_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("ref_expr_exprs", vec![id.into(), v.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("ref_expr_is_const", vec![id.into()]);
+        }
+        if self.is_mut {
+            out.add_tuple("ref_expr_is_mut", vec![id.into()]);
+        }
+        if self.is_raw {
+            out.add_tuple("ref_expr_is_raw", vec![id.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RefExpr {
+    fn class_name() -> &'static str { "RefExpr" }
+}
+
+impl From<trap::Label<RefExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RefExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<RefExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<RefExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RefExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RefPat {
+    pub id: trap::TrapId<RefPat>,
+    pub is_mut: bool,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for RefPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ref_pats", vec![id.into()]);
+        if self.is_mut {
+            out.add_tuple("ref_pat_is_mut", vec![id.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("ref_pat_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RefPat {
+    fn class_name() -> &'static str { "RefPat" }
+}
+
+impl From<trap::Label<RefPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RefPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<RefPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RefPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<RefPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RefTypeRepr {
+    pub id: trap::TrapId<RefTypeRepr>,
+    pub is_mut: bool,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for RefTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("ref_type_reprs", vec![id.into()]);
+        if self.is_mut {
+            out.add_tuple("ref_type_repr_is_mut", vec![id.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("ref_type_repr_lifetimes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("ref_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RefTypeRepr {
+    fn class_name() -> &'static str { "RefTypeRepr" }
+}
+
+impl From<trap::Label<RefTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RefTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<RefTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RefTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RefTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<RefTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RestPat {
+    pub id: trap::TrapId<RestPat>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for RestPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("rest_pats", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("rest_pat_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RestPat {
+    fn class_name() -> &'static str { "RestPat" }
+}
+
+impl From<trap::Label<RestPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RestPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RestPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<RestPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RestPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RestPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RestPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<RestPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ReturnExpr {
+    pub id: trap::TrapId<ReturnExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for ReturnExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("return_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("return_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("return_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ReturnExpr {
+    fn class_name() -> &'static str { "ReturnExpr" }
+}
+
+impl From<trap::Label<ReturnExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ReturnExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ReturnExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ReturnExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ReturnExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ReturnExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ReturnExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ReturnExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SelfParam {
+    pub id: trap::TrapId<SelfParam>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub is_mut: bool,
+    pub lifetime: Option<trap::Label<Lifetime>>,
+    pub name: Option<trap::Label<Name>>,
+}
+
+impl trap::TrapEntry for SelfParam {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("self_params", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("param_base_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("param_base_type_reprs", vec![id.into(), v.into()]);
+        }
+        if self.is_mut {
+            out.add_tuple("self_param_is_mut", vec![id.into()]);
+        }
+        if let Some(v) = self.lifetime {
+            out.add_tuple("self_param_lifetimes", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("self_param_names", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for SelfParam {
+    fn class_name() -> &'static str { "SelfParam" }
+}
+
+impl From<trap::Label<SelfParam>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<SelfParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SelfParam>> for trap::Label<Element> {
+    fn from(value: trap::Label<SelfParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SelfParam>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<SelfParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SelfParam>> for trap::Label<ParamBase> {
+    fn from(value: trap::Label<SelfParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of ParamBase
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SlicePat {
+    pub id: trap::TrapId<SlicePat>,
+    pub pats: Vec<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for SlicePat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("slice_pats", vec![id.into()]);
+        for (i, v) in self.pats.into_iter().enumerate() {
+            out.add_tuple("slice_pat_pats", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for SlicePat {
+    fn class_name() -> &'static str { "SlicePat" }
+}
+
+impl From<trap::Label<SlicePat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<SlicePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SlicePat>> for trap::Label<Element> {
+    fn from(value: trap::Label<SlicePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SlicePat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<SlicePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SlicePat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<SlicePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SliceTypeRepr {
+    pub id: trap::TrapId<SliceTypeRepr>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for SliceTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("slice_type_reprs", vec![id.into()]);
+        if let Some(v) = self.type_repr {
+            out.add_tuple("slice_type_repr_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for SliceTypeRepr {
+    fn class_name() -> &'static str { "SliceTypeRepr" }
+}
+
+impl From<trap::Label<SliceTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SliceTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SliceTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<SliceTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TryExpr {
+    pub id: trap::TrapId<TryExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for TryExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("try_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("try_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("try_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TryExpr {
+    fn class_name() -> &'static str { "TryExpr" }
+}
+
+impl From<trap::Label<TryExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TryExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<TryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TryExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<TryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TryExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TryExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TupleExpr {
+    pub id: trap::TrapId<TupleExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub fields: Vec<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for TupleExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("tuple_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("tuple_expr_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TupleExpr {
+    fn class_name() -> &'static str { "TupleExpr" }
+}
+
+impl From<trap::Label<TupleExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TupleExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<TupleExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<TupleExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TupleExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TupleFieldList {
+    pub id: trap::TrapId<TupleFieldList>,
+    pub fields: Vec<trap::Label<TupleField>>,
+}
+
+impl trap::TrapEntry for TupleFieldList {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_field_lists", vec![id.into()]);
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("tuple_field_list_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TupleFieldList {
+    fn class_name() -> &'static str { "TupleFieldList" }
+}
+
+impl From<trap::Label<TupleFieldList>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TupleFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleFieldList>> for trap::Label<Element> {
+    fn from(value: trap::Label<TupleFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleFieldList>> for trap::Label<FieldList> {
+    fn from(value: trap::Label<TupleFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of FieldList
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleFieldList>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TupleFieldList>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TuplePat {
+    pub id: trap::TrapId<TuplePat>,
+    pub fields: Vec<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for TuplePat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_pats", vec![id.into()]);
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("tuple_pat_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TuplePat {
+    fn class_name() -> &'static str { "TuplePat" }
+}
+
+impl From<trap::Label<TuplePat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TuplePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TuplePat>> for trap::Label<Element> {
+    fn from(value: trap::Label<TuplePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TuplePat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TuplePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TuplePat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<TuplePat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TupleTypeRepr {
+    pub id: trap::TrapId<TupleTypeRepr>,
+    pub fields: Vec<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for TupleTypeRepr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_type_reprs", vec![id.into()]);
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("tuple_type_repr_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TupleTypeRepr {
+    fn class_name() -> &'static str { "TupleTypeRepr" }
+}
+
+impl From<trap::Label<TupleTypeRepr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleTypeRepr>> for trap::Label<Element> {
+    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleTypeRepr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleTypeRepr>> for trap::Label<TypeRepr> {
+    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of TypeRepr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeArg {
+    pub id: trap::TrapId<TypeArg>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+}
+
+impl trap::TrapEntry for TypeArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_args", vec![id.into()]);
+        if let Some(v) = self.type_repr {
+            out.add_tuple("type_arg_type_reprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TypeArg {
+    fn class_name() -> &'static str { "TypeArg" }
+}
+
+impl From<trap::Label<TypeArg>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeArg>> for trap::Label<GenericArg> {
+    fn from(value: trap::Label<TypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of GenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeArg>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeParam {
+    pub id: trap::TrapId<TypeParam>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub default_type: Option<trap::Label<TypeRepr>>,
+    pub name: Option<trap::Label<Name>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+}
+
+impl trap::TrapEntry for TypeParam {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_params", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("type_param_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.default_type {
+            out.add_tuple("type_param_default_types", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("type_param_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("type_param_type_bound_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TypeParam {
+    fn class_name() -> &'static str { "TypeParam" }
+}
+
+impl From<trap::Label<TypeParam>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeParam>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeParam>> for trap::Label<GenericParam> {
+    fn from(value: trap::Label<TypeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of GenericParam
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeParam>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeParam>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UnderscoreExpr {
+    pub id: trap::TrapId<UnderscoreExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for UnderscoreExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("underscore_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("underscore_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for UnderscoreExpr {
+    fn class_name() -> &'static str { "UnderscoreExpr" }
+}
+
+impl From<trap::Label<UnderscoreExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UnderscoreExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UnderscoreExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<UnderscoreExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Variant {
+    pub id: trap::TrapId<Variant>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+    pub field_list: Option<trap::Label<FieldList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for Variant {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("variants", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("variant_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("variant_exprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.field_list {
+            out.add_tuple("variant_field_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("variant_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("variant_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Variant {
+    fn class_name() -> &'static str { "Variant" }
+}
+
+impl From<trap::Label<Variant>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Variant>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Variant>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Variant>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Variant>> for trap::Label<Element> {
+    fn from(value: trap::Label<Variant>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Variant>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Variant>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WildcardPat {
+    pub id: trap::TrapId<WildcardPat>,
+}
+
+impl trap::TrapEntry for WildcardPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("wildcard_pats", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for WildcardPat {
+    fn class_name() -> &'static str { "WildcardPat" }
+}
+
+impl From<trap::Label<WildcardPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<WildcardPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WildcardPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<WildcardPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WildcardPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<WildcardPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WildcardPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<WildcardPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct YeetExpr {
+    pub id: trap::TrapId<YeetExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for YeetExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("yeet_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("yeet_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("yeet_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for YeetExpr {
+    fn class_name() -> &'static str { "YeetExpr" }
+}
+
+impl From<trap::Label<YeetExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<YeetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YeetExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<YeetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YeetExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<YeetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YeetExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<YeetExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct YieldExpr {
+    pub id: trap::TrapId<YieldExpr>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub expr: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for YieldExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("yield_exprs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("yield_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.expr {
+            out.add_tuple("yield_expr_exprs", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for YieldExpr {
+    fn class_name() -> &'static str { "YieldExpr" }
+}
+
+impl From<trap::Label<YieldExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<YieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YieldExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<YieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YieldExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<YieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<YieldExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<YieldExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BlockExpr {
+    pub id: trap::TrapId<BlockExpr>,
+    pub label: Option<trap::Label<Label>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub is_async: bool,
+    pub is_const: bool,
+    pub is_gen: bool,
+    pub is_move: bool,
+    pub is_try: bool,
+    pub is_unsafe: bool,
+    pub stmt_list: Option<trap::Label<StmtList>>,
+}
+
+impl trap::TrapEntry for BlockExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("block_exprs", vec![id.into()]);
+        if let Some(v) = self.label {
+            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("block_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if self.is_async {
+            out.add_tuple("block_expr_is_async", vec![id.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("block_expr_is_const", vec![id.into()]);
+        }
+        if self.is_gen {
+            out.add_tuple("block_expr_is_gen", vec![id.into()]);
+        }
+        if self.is_move {
+            out.add_tuple("block_expr_is_move", vec![id.into()]);
+        }
+        if self.is_try {
+            out.add_tuple("block_expr_is_try", vec![id.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("block_expr_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.stmt_list {
+            out.add_tuple("block_expr_stmt_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for BlockExpr {
+    fn class_name() -> &'static str { "BlockExpr" }
+}
+
+impl From<trap::Label<BlockExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<BlockExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BlockExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<BlockExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BlockExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<BlockExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BlockExpr>> for trap::Label<LabelableExpr> {
+    fn from(value: trap::Label<BlockExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of LabelableExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BlockExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<BlockExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CallExpr {
+    pub id: trap::TrapId<CallExpr>,
+    pub arg_list: Option<trap::Label<ArgList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub function: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for CallExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("call_exprs", vec![id.into()]);
+        if let Some(v) = self.arg_list {
+            out.add_tuple("call_expr_base_arg_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("call_expr_base_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.function {
+            out.add_tuple("call_expr_functions", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for CallExpr {
+    fn class_name() -> &'static str { "CallExpr" }
+}
+
+impl From<trap::Label<CallExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<CallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExpr>> for trap::Label<CallExprBase> {
+    fn from(value: trap::Label<CallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of CallExprBase
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<CallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<CallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CallExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<CallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Const {
+    pub id: trap::TrapId<Const>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub body: Option<trap::Label<Expr>>,
+    pub is_const: bool,
+    pub is_default: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for Const {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("consts", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("const_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.body {
+            out.add_tuple("const_bodies", vec![id.into(), v.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("const_is_const", vec![id.into()]);
+        }
+        if self.is_default {
+            out.add_tuple("const_is_default", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("const_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("const_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("const_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Const {
+    fn class_name() -> &'static str { "Const" }
+}
+
+impl From<trap::Label<Const>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<AssocItem> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of AssocItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<Element> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<Item> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Const>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Const>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Enum {
+    pub id: trap::TrapId<Enum>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub variant_list: Option<trap::Label<VariantList>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Enum {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("enums", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("enum_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("enum_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("enum_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.variant_list {
+            out.add_tuple("enum_variant_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("enum_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("enum_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Enum {
+    fn class_name() -> &'static str { "Enum" }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<Element> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<Item> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Enum>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Enum>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExternBlock {
+    pub id: trap::TrapId<ExternBlock>,
+    pub abi: Option<trap::Label<Abi>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub extern_item_list: Option<trap::Label<ExternItemList>>,
+    pub is_unsafe: bool,
+}
+
+impl trap::TrapEntry for ExternBlock {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("extern_blocks", vec![id.into()]);
+        if let Some(v) = self.abi {
+            out.add_tuple("extern_block_abis", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("extern_block_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.extern_item_list {
+            out.add_tuple("extern_block_extern_item_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("extern_block_is_unsafe", vec![id.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ExternBlock {
+    fn class_name() -> &'static str { "ExternBlock" }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<Item> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternBlock>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<ExternBlock>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExternCrate {
+    pub id: trap::TrapId<ExternCrate>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+    pub rename: Option<trap::Label<Rename>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for ExternCrate {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("extern_crates", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("extern_crate_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("extern_crate_name_refs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.rename {
+            out.add_tuple("extern_crate_renames", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("extern_crate_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ExternCrate {
+    fn class_name() -> &'static str { "ExternCrate" }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<Element> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<Item> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ExternCrate>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<ExternCrate>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Function {
+    pub id: trap::TrapId<Function>,
+    pub param_list: Option<trap::Label<ParamList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub abi: Option<trap::Label<Abi>>,
+    pub body: Option<trap::Label<BlockExpr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub is_async: bool,
+    pub is_const: bool,
+    pub is_default: bool,
+    pub is_gen: bool,
+    pub is_unsafe: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub ret_type: Option<trap::Label<RetTypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Function {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("functions", vec![id.into()]);
+        if let Some(v) = self.param_list {
+            out.add_tuple("callable_param_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("callable_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.abi {
+            out.add_tuple("function_abis", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.body {
+            out.add_tuple("function_bodies", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("function_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_async {
+            out.add_tuple("function_is_async", vec![id.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("function_is_const", vec![id.into()]);
+        }
+        if self.is_default {
+            out.add_tuple("function_is_default", vec![id.into()]);
+        }
+        if self.is_gen {
+            out.add_tuple("function_is_gen", vec![id.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("function_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("function_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.ret_type {
+            out.add_tuple("function_ret_types", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("function_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("function_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Function {
+    fn class_name() -> &'static str { "Function" }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<AssocItem> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of AssocItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Callable> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Callable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Element> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<ExternItem> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of ExternItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Item> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Function>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Function>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Impl {
+    pub id: trap::TrapId<Impl>,
+    pub assoc_item_list: Option<trap::Label<AssocItemList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub is_const: bool,
+    pub is_default: bool,
+    pub is_unsafe: bool,
+    pub self_ty: Option<trap::Label<TypeRepr>>,
+    pub trait_: Option<trap::Label<TypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Impl {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("impls", vec![id.into()]);
+        if let Some(v) = self.assoc_item_list {
+            out.add_tuple("impl_assoc_item_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("impl_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("impl_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_const {
+            out.add_tuple("impl_is_const", vec![id.into()]);
+        }
+        if self.is_default {
+            out.add_tuple("impl_is_default", vec![id.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("impl_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.self_ty {
+            out.add_tuple("impl_self_ties", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.trait_ {
+            out.add_tuple("impl_traits", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("impl_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("impl_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Impl {
+    fn class_name() -> &'static str { "Impl" }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<Element> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<Item> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Impl>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Impl>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LoopingExpr {
+    _unused: ()
+}
+
+impl trap::TrapClass for LoopingExpr {
+    fn class_name() -> &'static str { "LoopingExpr" }
+}
+
+impl From<trap::Label<LoopingExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LoopingExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopingExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<LoopingExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopingExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<LoopingExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopingExpr>> for trap::Label<LabelableExpr> {
+    fn from(value: trap::Label<LoopingExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of LabelableExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopingExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LoopingExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroCall {
+    pub id: trap::TrapId<MacroCall>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub path: Option<trap::Label<Path>>,
+    pub token_tree: Option<trap::Label<TokenTree>>,
+}
+
+impl trap::TrapEntry for MacroCall {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_calls", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("macro_call_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.path {
+            out.add_tuple("macro_call_paths", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.token_tree {
+            out.add_tuple("macro_call_token_trees", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl MacroCall {
+    pub fn emit_expanded(id: trap::Label<Self>, value: trap::Label<AstNode>, out: &mut trap::Writer) {
+        out.add_tuple("macro_call_expandeds", vec![id.into(), value.into()]);
+    }
+}
+
+impl trap::TrapClass for MacroCall {
+    fn class_name() -> &'static str { "MacroCall" }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<AssocItem> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AssocItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<ExternItem> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of ExternItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<Item> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroCall>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<MacroCall>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroDef {
+    pub id: trap::TrapId<MacroDef>,
+    pub args: Option<trap::Label<TokenTree>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub body: Option<trap::Label<TokenTree>>,
+    pub name: Option<trap::Label<Name>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for MacroDef {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_defs", vec![id.into()]);
+        if let Some(v) = self.args {
+            out.add_tuple("macro_def_args", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("macro_def_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.body {
+            out.add_tuple("macro_def_bodies", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("macro_def_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("macro_def_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroDef {
+    fn class_name() -> &'static str { "MacroDef" }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<Item> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroDef>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<MacroDef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MacroRules {
+    pub id: trap::TrapId<MacroRules>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub name: Option<trap::Label<Name>>,
+    pub token_tree: Option<trap::Label<TokenTree>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for MacroRules {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("macro_rules", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("macro_rules_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("macro_rules_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.token_tree {
+            out.add_tuple("macro_rules_token_trees", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("macro_rules_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MacroRules {
+    fn class_name() -> &'static str { "MacroRules" }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<Element> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<Item> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MacroRules>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<MacroRules>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MethodCallExpr {
+    pub id: trap::TrapId<MethodCallExpr>,
+    pub arg_list: Option<trap::Label<ArgList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
+    pub name_ref: Option<trap::Label<NameRef>>,
+    pub receiver: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for MethodCallExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("method_call_exprs", vec![id.into()]);
+        if let Some(v) = self.arg_list {
+            out.add_tuple("call_expr_base_arg_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("call_expr_base_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_arg_list {
+            out.add_tuple("method_call_expr_generic_arg_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name_ref {
+            out.add_tuple("method_call_expr_name_refs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.receiver {
+            out.add_tuple("method_call_expr_receivers", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for MethodCallExpr {
+    fn class_name() -> &'static str { "MethodCallExpr" }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<CallExprBase> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of CallExprBase
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<MethodCallExpr>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<MethodCallExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Module {
+    pub id: trap::TrapId<Module>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub item_list: Option<trap::Label<ItemList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for Module {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("modules", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("module_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.item_list {
+            out.add_tuple("module_item_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("module_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("module_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Module {
+    fn class_name() -> &'static str { "Module" }
+}
+
+impl From<trap::Label<Module>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Module>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Module>> for trap::Label<Element> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Module>> for trap::Label<Item> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Module>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Module>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Module>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathExpr {
+    pub id: trap::TrapId<PathExpr>,
+    pub path: Option<trap::Label<Path>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for PathExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("path_exprs", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("path_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PathExpr {
+    fn class_name() -> &'static str { "PathExpr" }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<PathAstNode> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathAstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<PathExprBase> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathExprBase
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathExpr>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<PathExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathPat {
+    pub id: trap::TrapId<PathPat>,
+    pub path: Option<trap::Label<Path>>,
+}
+
+impl trap::TrapEntry for PathPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("path_pats", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for PathPat {
+    fn class_name() -> &'static str { "PathPat" }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<PathAstNode> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of PathAstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PathPat>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<PathPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordExpr {
+    pub id: trap::TrapId<RecordExpr>,
+    pub path: Option<trap::Label<Path>>,
+    pub record_expr_field_list: Option<trap::Label<RecordExprFieldList>>,
+}
+
+impl trap::TrapEntry for RecordExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_exprs", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.record_expr_field_list {
+            out.add_tuple("record_expr_record_expr_field_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordExpr {
+    fn class_name() -> &'static str { "RecordExpr" }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<PathAstNode> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of PathAstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordExpr>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<RecordExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RecordPat {
+    pub id: trap::TrapId<RecordPat>,
+    pub path: Option<trap::Label<Path>>,
+    pub record_pat_field_list: Option<trap::Label<RecordPatFieldList>>,
+}
+
+impl trap::TrapEntry for RecordPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("record_pats", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.record_pat_field_list {
+            out.add_tuple("record_pat_record_pat_field_lists", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RecordPat {
+    fn class_name() -> &'static str { "RecordPat" }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<PathAstNode> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of PathAstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RecordPat>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<RecordPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Static {
+    pub id: trap::TrapId<Static>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub body: Option<trap::Label<Expr>>,
+    pub is_mut: bool,
+    pub is_static: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for Static {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("statics", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("static_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.body {
+            out.add_tuple("static_bodies", vec![id.into(), v.into()]);
+        }
+        if self.is_mut {
+            out.add_tuple("static_is_mut", vec![id.into()]);
+        }
+        if self.is_static {
+            out.add_tuple("static_is_static", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("static_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("static_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("static_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Static {
+    fn class_name() -> &'static str { "Static" }
+}
+
+impl From<trap::Label<Static>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<Element> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<ExternItem> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of ExternItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<Item> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Static>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Static>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Struct {
+    pub id: trap::TrapId<Struct>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub field_list: Option<trap::Label<FieldList>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Struct {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("structs", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("struct_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.field_list {
+            out.add_tuple("struct_field_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("struct_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("struct_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("struct_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("struct_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Struct {
+    fn class_name() -> &'static str { "Struct" }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<Element> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<Item> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Struct>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Struct>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Trait {
+    pub id: trap::TrapId<Trait>,
+    pub assoc_item_list: Option<trap::Label<AssocItemList>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub is_auto: bool,
+    pub is_unsafe: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Trait {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("traits", vec![id.into()]);
+        if let Some(v) = self.assoc_item_list {
+            out.add_tuple("trait_assoc_item_lists", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("trait_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("trait_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_auto {
+            out.add_tuple("trait_is_auto", vec![id.into()]);
+        }
+        if self.is_unsafe {
+            out.add_tuple("trait_is_unsafe", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("trait_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("trait_type_bound_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("trait_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("trait_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Trait {
+    fn class_name() -> &'static str { "Trait" }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<Element> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<Item> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Trait>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Trait>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TraitAlias {
+    pub id: trap::TrapId<TraitAlias>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for TraitAlias {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("trait_aliases", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("trait_alias_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("trait_alias_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("trait_alias_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("trait_alias_type_bound_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("trait_alias_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("trait_alias_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TraitAlias {
+    fn class_name() -> &'static str { "TraitAlias" }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<Element> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<Item> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitAlias>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<TraitAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TupleStructPat {
+    pub id: trap::TrapId<TupleStructPat>,
+    pub path: Option<trap::Label<Path>>,
+    pub fields: Vec<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for TupleStructPat {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("tuple_struct_pats", vec![id.into()]);
+        if let Some(v) = self.path {
+            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.fields.into_iter().enumerate() {
+            out.add_tuple("tuple_struct_pat_fields", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TupleStructPat {
+    fn class_name() -> &'static str { "TupleStructPat" }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<Element> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<Pat> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Pat
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<PathAstNode> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of PathAstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TupleStructPat>> for trap::Label<Resolvable> {
+    fn from(value: trap::Label<TupleStructPat>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Resolvable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeAlias {
+    pub id: trap::TrapId<TypeAlias>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub is_default: bool,
+    pub name: Option<trap::Label<Name>>,
+    pub type_repr: Option<trap::Label<TypeRepr>>,
+    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for TypeAlias {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_aliases", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("type_alias_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("type_alias_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if self.is_default {
+            out.add_tuple("type_alias_is_default", vec![id.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("type_alias_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_repr {
+            out.add_tuple("type_alias_type_reprs", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.type_bound_list {
+            out.add_tuple("type_alias_type_bound_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("type_alias_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("type_alias_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for TypeAlias {
+    fn class_name() -> &'static str { "TypeAlias" }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<AssocItem> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AssocItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<ExternItem> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of ExternItem
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<Item> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeAlias>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<TypeAlias>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Union {
+    pub id: trap::TrapId<Union>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub generic_param_list: Option<trap::Label<GenericParamList>>,
+    pub name: Option<trap::Label<Name>>,
+    pub record_field_list: Option<trap::Label<RecordFieldList>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+    pub where_clause: Option<trap::Label<WhereClause>>,
+}
+
+impl trap::TrapEntry for Union {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("unions", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("union_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.generic_param_list {
+            out.add_tuple("union_generic_param_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.name {
+            out.add_tuple("union_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.record_field_list {
+            out.add_tuple("union_record_field_lists", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("union_visibilities", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.where_clause {
+            out.add_tuple("union_where_clauses", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Union {
+    fn class_name() -> &'static str { "Union" }
+}
+
+impl From<trap::Label<Union>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Union>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Union>> for trap::Label<Element> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Union>> for trap::Label<Item> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Union>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Union>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Union>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Use {
+    pub id: trap::TrapId<Use>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub use_tree: Option<trap::Label<UseTree>>,
+    pub visibility: Option<trap::Label<Visibility>>,
+}
+
+impl trap::TrapEntry for Use {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("uses", vec![id.into()]);
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("use_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.use_tree {
+            out.add_tuple("use_use_trees", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.visibility {
+            out.add_tuple("use_visibilities", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for Use {
+    fn class_name() -> &'static str { "Use" }
+}
+
+impl From<trap::Label<Use>> for trap::Label<Addressable> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Addressable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Use>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Use>> for trap::Label<Element> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Use>> for trap::Label<Item> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Item
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Use>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Use>> for trap::Label<Stmt> {
+    fn from(value: trap::Label<Use>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Stmt
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ForExpr {
+    pub id: trap::TrapId<ForExpr>,
+    pub label: Option<trap::Label<Label>>,
+    pub loop_body: Option<trap::Label<BlockExpr>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub iterable: Option<trap::Label<Expr>>,
+    pub pat: Option<trap::Label<Pat>>,
+}
+
+impl trap::TrapEntry for ForExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("for_exprs", vec![id.into()]);
+        if let Some(v) = self.label {
+            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.loop_body {
+            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("for_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.iterable {
+            out.add_tuple("for_expr_iterables", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.pat {
+            out.add_tuple("for_expr_pats", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ForExpr {
+    fn class_name() -> &'static str { "ForExpr" }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<LabelableExpr> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LabelableExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ForExpr>> for trap::Label<LoopingExpr> {
+    fn from(value: trap::Label<ForExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LoopingExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LoopExpr {
+    pub id: trap::TrapId<LoopExpr>,
+    pub label: Option<trap::Label<Label>>,
+    pub loop_body: Option<trap::Label<BlockExpr>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+}
+
+impl trap::TrapEntry for LoopExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("loop_exprs", vec![id.into()]);
+        if let Some(v) = self.label {
+            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.loop_body {
+            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("loop_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for LoopExpr {
+    fn class_name() -> &'static str { "LoopExpr" }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<LabelableExpr> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LabelableExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LoopExpr>> for trap::Label<LoopingExpr> {
+    fn from(value: trap::Label<LoopExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LoopingExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WhileExpr {
+    pub id: trap::TrapId<WhileExpr>,
+    pub label: Option<trap::Label<Label>>,
+    pub loop_body: Option<trap::Label<BlockExpr>>,
+    pub attrs: Vec<trap::Label<Attr>>,
+    pub condition: Option<trap::Label<Expr>>,
+}
+
+impl trap::TrapEntry for WhileExpr {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("while_exprs", vec![id.into()]);
+        if let Some(v) = self.label {
+            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.loop_body {
+            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
+        }
+        for (i, v) in self.attrs.into_iter().enumerate() {
+            out.add_tuple("while_expr_attrs", vec![id.into(), i.into(), v.into()]);
+        }
+        if let Some(v) = self.condition {
+            out.add_tuple("while_expr_conditions", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for WhileExpr {
+    fn class_name() -> &'static str { "WhileExpr" }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<Expr> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Expr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<LabelableExpr> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LabelableExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<Locatable> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Locatable
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<WhileExpr>> for trap::Label<LoopingExpr> {
+    fn from(value: trap::Label<WhileExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LoopingExpr
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CanonicalPathElement {
+    _unused: ()
+}
+
+impl trap::TrapClass for CanonicalPathElement {
+    fn class_name() -> &'static str { "CanonicalPathElement" }
+}
+
+impl From<trap::Label<CanonicalPathElement>> for trap::Label<Element> {
+    fn from(value: trap::Label<CanonicalPathElement>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CanonicalPathElement is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CanonicalPath {
+    _unused: ()
+}
+
+impl trap::TrapClass for CanonicalPath {
+    fn class_name() -> &'static str { "CanonicalPath" }
+}
+
+impl From<trap::Label<CanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<CanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<CanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CrateRef {
+    _unused: ()
+}
+
+impl trap::TrapClass for CrateRef {
+    fn class_name() -> &'static str { "CrateRef" }
+}
+
+impl From<trap::Label<CrateRef>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<CrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CrateRef is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<CrateRef>> for trap::Label<Element> {
+    fn from(value: trap::Label<CrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme CrateRef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeGenericArg {
+    _unused: ()
+}
+
+impl trap::TrapClass for TypeGenericArg {
+    fn class_name() -> &'static str { "TypeGenericArg" }
+}
+
+impl From<trap::Label<TypeGenericArg>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TypeGenericArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeGenericArg is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeGenericArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeGenericArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeGenericArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConstGenericTypeArg {
+    pub id: trap::TrapId<ConstGenericTypeArg>,
+    pub value: String,
+}
+
+impl trap::TrapEntry for ConstGenericTypeArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("const_generic_type_args", vec![id.into(), self.value.into()]);
+    }
+}
+
+impl trap::TrapClass for ConstGenericTypeArg {
+    fn class_name() -> &'static str { "ConstGenericTypeArg" }
+}
+
+impl From<trap::Label<ConstGenericTypeArg>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<ConstGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstGenericTypeArg is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstGenericTypeArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<ConstGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstGenericTypeArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConstGenericTypeArg>> for trap::Label<TypeGenericArg> {
+    fn from(value: trap::Label<ConstGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConstGenericTypeArg is a subclass of TypeGenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LangCrateRef {
+    pub id: trap::TrapId<LangCrateRef>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for LangCrateRef {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("lang_crate_refs", vec![id.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for LangCrateRef {
+    fn class_name() -> &'static str { "LangCrateRef" }
+}
+
+impl From<trap::Label<LangCrateRef>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<LangCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LangCrateRef is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LangCrateRef>> for trap::Label<CrateRef> {
+    fn from(value: trap::Label<LangCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LangCrateRef is a subclass of CrateRef
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<LangCrateRef>> for trap::Label<Element> {
+    fn from(value: trap::Label<LangCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme LangCrateRef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ModuleItemCanonicalPath {
+    pub id: trap::TrapId<ModuleItemCanonicalPath>,
+    pub namespace: trap::Label<Namespace>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for ModuleItemCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("module_item_canonical_paths", vec![id.into(), self.namespace.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for ModuleItemCanonicalPath {
+    fn class_name() -> &'static str { "ModuleItemCanonicalPath" }
+}
+
+impl From<trap::Label<ModuleItemCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<ModuleItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ModuleItemCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ModuleItemCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<ModuleItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ModuleItemCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ModuleItemCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<ModuleItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ModuleItemCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Namespace {
+    pub id: trap::TrapId<Namespace>,
+    pub root: trap::Label<CrateRef>,
+    pub path: String,
+}
+
+impl trap::TrapEntry for Namespace {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("namespaces", vec![id.into(), self.root.into(), self.path.into()]);
+    }
+}
+
+impl trap::TrapClass for Namespace {
+    fn class_name() -> &'static str { "Namespace" }
+}
+
+impl From<trap::Label<Namespace>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<Namespace>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Namespace is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Namespace>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<Namespace>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Namespace is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<Namespace>> for trap::Label<Element> {
+    fn from(value: trap::Label<Namespace>) -> Self {
+        // SAFETY: this is safe because in the dbscheme Namespace is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParametrizedCanonicalPath {
+    pub id: trap::TrapId<ParametrizedCanonicalPath>,
+    pub base: trap::Label<ModuleItemCanonicalPath>,
+    pub generic_args: Vec<trap::Label<TypeGenericArg>>,
+}
+
+impl trap::TrapEntry for ParametrizedCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("parametrized_canonical_paths", vec![id.into(), self.base.into()]);
+        for (i, v) in self.generic_args.into_iter().enumerate() {
+            out.add_tuple("parametrized_canonical_path_generic_args", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for ParametrizedCanonicalPath {
+    fn class_name() -> &'static str { "ParametrizedCanonicalPath" }
+}
+
+impl From<trap::Label<ParametrizedCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<ParametrizedCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParametrizedCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParametrizedCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<ParametrizedCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParametrizedCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ParametrizedCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<ParametrizedCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ParametrizedCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RepoCrateRef {
+    pub id: trap::TrapId<RepoCrateRef>,
+    pub name: Option<String>,
+    pub repo: Option<String>,
+    pub source: trap::Label<File>,
+}
+
+impl trap::TrapEntry for RepoCrateRef {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("repo_crate_refs", vec![id.into(), self.source.into()]);
+        if let Some(v) = self.name {
+            out.add_tuple("repo_crate_ref_names", vec![id.into(), v.into()]);
+        }
+        if let Some(v) = self.repo {
+            out.add_tuple("repo_crate_ref_repos", vec![id.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for RepoCrateRef {
+    fn class_name() -> &'static str { "RepoCrateRef" }
+}
+
+impl From<trap::Label<RepoCrateRef>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<RepoCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RepoCrateRef is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RepoCrateRef>> for trap::Label<CrateRef> {
+    fn from(value: trap::Label<RepoCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RepoCrateRef is a subclass of CrateRef
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RepoCrateRef>> for trap::Label<Element> {
+    fn from(value: trap::Label<RepoCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RepoCrateRef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct RustcCrateRef {
+    pub id: trap::TrapId<RustcCrateRef>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for RustcCrateRef {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("rustc_crate_refs", vec![id.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for RustcCrateRef {
+    fn class_name() -> &'static str { "RustcCrateRef" }
+}
+
+impl From<trap::Label<RustcCrateRef>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<RustcCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RustcCrateRef is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RustcCrateRef>> for trap::Label<CrateRef> {
+    fn from(value: trap::Label<RustcCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RustcCrateRef is a subclass of CrateRef
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<RustcCrateRef>> for trap::Label<Element> {
+    fn from(value: trap::Label<RustcCrateRef>) -> Self {
+        // SAFETY: this is safe because in the dbscheme RustcCrateRef is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TraitImplItemCanonicalPath {
+    pub id: trap::TrapId<TraitImplItemCanonicalPath>,
+    pub type_path: trap::Label<TypeCanonicalPath>,
+    pub trait_path: trap::Label<ParametrizedCanonicalPath>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for TraitImplItemCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("trait_impl_item_canonical_paths", vec![id.into(), self.type_path.into(), self.trait_path.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for TraitImplItemCanonicalPath {
+    fn class_name() -> &'static str { "TraitImplItemCanonicalPath" }
+}
+
+impl From<trap::Label<TraitImplItemCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<TraitImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitImplItemCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitImplItemCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TraitImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitImplItemCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TraitImplItemCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<TraitImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TraitImplItemCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeCanonicalPath {
+    _unused: ()
+}
+
+impl trap::TrapClass for TypeCanonicalPath {
+    fn class_name() -> &'static str { "TypeCanonicalPath" }
+}
+
+impl From<trap::Label<TypeCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<TypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeGenericTypeArg {
+    pub id: trap::TrapId<TypeGenericTypeArg>,
+    pub path: trap::Label<TypeCanonicalPath>,
+}
+
+impl trap::TrapEntry for TypeGenericTypeArg {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_generic_type_args", vec![id.into(), self.path.into()]);
+    }
+}
+
+impl trap::TrapClass for TypeGenericTypeArg {
+    fn class_name() -> &'static str { "TypeGenericTypeArg" }
+}
+
+impl From<trap::Label<TypeGenericTypeArg>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TypeGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeGenericTypeArg is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeGenericTypeArg>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeGenericTypeArg is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeGenericTypeArg>> for trap::Label<TypeGenericArg> {
+    fn from(value: trap::Label<TypeGenericTypeArg>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeGenericTypeArg is a subclass of TypeGenericArg
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeImplItemCanonicalPath {
+    pub id: trap::TrapId<TypeImplItemCanonicalPath>,
+    pub parent: trap::Label<ModuleItemCanonicalPath>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for TypeImplItemCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_impl_item_canonical_paths", vec![id.into(), self.parent.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for TypeImplItemCanonicalPath {
+    fn class_name() -> &'static str { "TypeImplItemCanonicalPath" }
+}
+
+impl From<trap::Label<TypeImplItemCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<TypeImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeImplItemCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeImplItemCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TypeImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeImplItemCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeImplItemCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeImplItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeImplItemCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TypeItemCanonicalPath {
+    pub id: trap::TrapId<TypeItemCanonicalPath>,
+    pub parent: trap::Label<ModuleItemCanonicalPath>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for TypeItemCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("type_item_canonical_paths", vec![id.into(), self.parent.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for TypeItemCanonicalPath {
+    fn class_name() -> &'static str { "TypeItemCanonicalPath" }
+}
+
+impl From<trap::Label<TypeItemCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<TypeItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeItemCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeItemCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<TypeItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeItemCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<TypeItemCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<TypeItemCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme TypeItemCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BuiltinTypeCanonicalPath {
+    pub id: trap::TrapId<BuiltinTypeCanonicalPath>,
+    pub name: String,
+}
+
+impl trap::TrapEntry for BuiltinTypeCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("builtin_type_canonical_paths", vec![id.into(), self.name.into()]);
+    }
+}
+
+impl trap::TrapClass for BuiltinTypeCanonicalPath {
+    fn class_name() -> &'static str { "BuiltinTypeCanonicalPath" }
+}
+
+impl From<trap::Label<BuiltinTypeCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<BuiltinTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BuiltinTypeCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BuiltinTypeCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<BuiltinTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BuiltinTypeCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BuiltinTypeCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<BuiltinTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BuiltinTypeCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<BuiltinTypeCanonicalPath>> for trap::Label<TypeCanonicalPath> {
+    fn from(value: trap::Label<BuiltinTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme BuiltinTypeCanonicalPath is a subclass of TypeCanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConcreteTypeCanonicalPath {
+    pub id: trap::TrapId<ConcreteTypeCanonicalPath>,
+    pub path: trap::Label<ParametrizedCanonicalPath>,
+}
+
+impl trap::TrapEntry for ConcreteTypeCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("concrete_type_canonical_paths", vec![id.into(), self.path.into()]);
+    }
+}
+
+impl trap::TrapClass for ConcreteTypeCanonicalPath {
+    fn class_name() -> &'static str { "ConcreteTypeCanonicalPath" }
+}
+
+impl From<trap::Label<ConcreteTypeCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<ConcreteTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConcreteTypeCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConcreteTypeCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<ConcreteTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConcreteTypeCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConcreteTypeCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<ConcreteTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConcreteTypeCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<ConcreteTypeCanonicalPath>> for trap::Label<TypeCanonicalPath> {
+    fn from(value: trap::Label<ConcreteTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme ConcreteTypeCanonicalPath is a subclass of TypeCanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct DerivedTypeCanonicalPath {
+    pub id: trap::TrapId<DerivedTypeCanonicalPath>,
+    pub modifiers: Vec<String>,
+    pub base: Vec<trap::Label<TypeCanonicalPath>>,
+}
+
+impl trap::TrapEntry for DerivedTypeCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("derived_type_canonical_paths", vec![id.into()]);
+        for (i, v) in self.modifiers.into_iter().enumerate() {
+            out.add_tuple("derived_type_canonical_path_modifiers", vec![id.into(), i.into(), v.into()]);
+        }
+        for (i, v) in self.base.into_iter().enumerate() {
+            out.add_tuple("derived_type_canonical_path_bases", vec![id.into(), i.into(), v.into()]);
+        }
+    }
+}
+
+impl trap::TrapClass for DerivedTypeCanonicalPath {
+    fn class_name() -> &'static str { "DerivedTypeCanonicalPath" }
+}
+
+impl From<trap::Label<DerivedTypeCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<DerivedTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DerivedTypeCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DerivedTypeCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<DerivedTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DerivedTypeCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DerivedTypeCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<DerivedTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DerivedTypeCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<DerivedTypeCanonicalPath>> for trap::Label<TypeCanonicalPath> {
+    fn from(value: trap::Label<DerivedTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme DerivedTypeCanonicalPath is a subclass of TypeCanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PlaceholderTypeCanonicalPath {
+    pub id: trap::TrapId<PlaceholderTypeCanonicalPath>,
+}
+
+impl trap::TrapEntry for PlaceholderTypeCanonicalPath {
+    fn extract_id(&mut self) -> trap::TrapId<Self> {
+        std::mem::replace(&mut self.id, trap::TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
+        out.add_tuple("placeholder_type_canonical_paths", vec![id.into()]);
+    }
+}
+
+impl trap::TrapClass for PlaceholderTypeCanonicalPath {
+    fn class_name() -> &'static str { "PlaceholderTypeCanonicalPath" }
+}
+
+impl From<trap::Label<PlaceholderTypeCanonicalPath>> for trap::Label<CanonicalPath> {
+    fn from(value: trap::Label<PlaceholderTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PlaceholderTypeCanonicalPath is a subclass of CanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PlaceholderTypeCanonicalPath>> for trap::Label<CanonicalPathElement> {
+    fn from(value: trap::Label<PlaceholderTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PlaceholderTypeCanonicalPath is a subclass of CanonicalPathElement
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PlaceholderTypeCanonicalPath>> for trap::Label<Element> {
+    fn from(value: trap::Label<PlaceholderTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PlaceholderTypeCanonicalPath is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
+impl From<trap::Label<PlaceholderTypeCanonicalPath>> for trap::Label<TypeCanonicalPath> {
+    fn from(value: trap::Label<PlaceholderTypeCanonicalPath>) -> Self {
+        // SAFETY: this is safe because in the dbscheme PlaceholderTypeCanonicalPath is a subclass of TypeCanonicalPath
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
diff --git a/rust/extractor/src/generated/top.rs b/rust/extractor/src/generated/top.rs
deleted file mode 100644
index ee61282295da..000000000000
--- a/rust/extractor/src/generated/top.rs
+++ /dev/null
@@ -1,10600 +0,0 @@
-// generated by codegen, do not edit
-
-#![cfg_attr(any(), rustfmt::skip)]
-
-use crate::trap;
-
-#[derive(Debug)]
-pub struct File {
-    _unused: ()
-}
-
-impl trap::TrapClass for File {
-    fn class_name() -> &'static str { "File" }
-}
-
-#[derive(Debug)]
-pub struct Element {
-    _unused: ()
-}
-
-impl trap::TrapClass for Element {
-    fn class_name() -> &'static str { "Element" }
-}
-
-#[derive(Debug)]
-pub struct ExtractorStep {
-    pub id: trap::TrapId<ExtractorStep>,
-    pub action: String,
-    pub file: trap::Label<File>,
-    pub duration_ms: usize,
-}
-
-impl trap::TrapEntry for ExtractorStep {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("extractor_steps", vec![id.into(), self.action.into(), self.file.into(), self.duration_ms.into()]);
-    }
-}
-
-impl trap::TrapClass for ExtractorStep {
-    fn class_name() -> &'static str { "ExtractorStep" }
-}
-
-impl From<trap::Label<ExtractorStep>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExtractorStep>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExtractorStep is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Locatable {
-    _unused: ()
-}
-
-impl trap::TrapClass for Locatable {
-    fn class_name() -> &'static str { "Locatable" }
-}
-
-impl From<trap::Label<Locatable>> for trap::Label<Element> {
-    fn from(value: trap::Label<Locatable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Locatable is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Unextracted {
-    _unused: ()
-}
-
-impl trap::TrapClass for Unextracted {
-    fn class_name() -> &'static str { "Unextracted" }
-}
-
-impl From<trap::Label<Unextracted>> for trap::Label<Element> {
-    fn from(value: trap::Label<Unextracted>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Unextracted is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AstNode {
-    _unused: ()
-}
-
-impl trap::TrapClass for AstNode {
-    fn class_name() -> &'static str { "AstNode" }
-}
-
-impl From<trap::Label<AstNode>> for trap::Label<Element> {
-    fn from(value: trap::Label<AstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AstNode>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Missing {
-    pub id: trap::TrapId<Missing>,
-}
-
-impl trap::TrapEntry for Missing {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("missings", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for Missing {
-    fn class_name() -> &'static str { "Missing" }
-}
-
-impl From<trap::Label<Missing>> for trap::Label<Element> {
-    fn from(value: trap::Label<Missing>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Missing>> for trap::Label<Unextracted> {
-    fn from(value: trap::Label<Missing>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Unextracted
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Unimplemented {
-    pub id: trap::TrapId<Unimplemented>,
-}
-
-impl trap::TrapEntry for Unimplemented {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("unimplementeds", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for Unimplemented {
-    fn class_name() -> &'static str { "Unimplemented" }
-}
-
-impl From<trap::Label<Unimplemented>> for trap::Label<Element> {
-    fn from(value: trap::Label<Unimplemented>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Unimplemented>> for trap::Label<Unextracted> {
-    fn from(value: trap::Label<Unimplemented>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Unextracted
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Abi {
-    pub id: trap::TrapId<Abi>,
-    pub abi_string: Option<String>,
-}
-
-impl trap::TrapEntry for Abi {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("abis", vec![id.into()]);
-        if let Some(v) = self.abi_string {
-            out.add_tuple("abi_abi_strings", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Abi {
-    fn class_name() -> &'static str { "Abi" }
-}
-
-impl From<trap::Label<Abi>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Abi>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Abi is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Abi>> for trap::Label<Element> {
-    fn from(value: trap::Label<Abi>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Abi>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Abi>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Addressable {
-    _unused: ()
-}
-
-impl Addressable {
-    pub fn emit_extended_canonical_path(id: trap::Label<Self>, value: String, out: &mut trap::Writer) {
-        out.add_tuple("addressable_extended_canonical_paths", vec![id.into(), value.into()]);
-    }
-    pub fn emit_crate_origin(id: trap::Label<Self>, value: String, out: &mut trap::Writer) {
-        out.add_tuple("addressable_crate_origins", vec![id.into(), value.into()]);
-    }
-}
-
-impl trap::TrapClass for Addressable {
-    fn class_name() -> &'static str { "Addressable" }
-}
-
-impl From<trap::Label<Addressable>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Addressable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Addressable>> for trap::Label<Element> {
-    fn from(value: trap::Label<Addressable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Addressable>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Addressable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ArgList {
-    pub id: trap::TrapId<ArgList>,
-    pub args: Vec<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for ArgList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("arg_lists", vec![id.into()]);
-        for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("arg_list_args", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ArgList {
-    fn class_name() -> &'static str { "ArgList" }
-}
-
-impl From<trap::Label<ArgList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArgList>> for trap::Label<Element> {
-    fn from(value: trap::Label<ArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArgList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AssocItem {
-    _unused: ()
-}
-
-impl trap::TrapClass for AssocItem {
-    fn class_name() -> &'static str { "AssocItem" }
-}
-
-impl From<trap::Label<AssocItem>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<AssocItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocItem>> for trap::Label<Element> {
-    fn from(value: trap::Label<AssocItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocItem>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AssocItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AssocItemList {
-    pub id: trap::TrapId<AssocItemList>,
-    pub assoc_items: Vec<trap::Label<AssocItem>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for AssocItemList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("assoc_item_lists", vec![id.into()]);
-        for (i, v) in self.assoc_items.into_iter().enumerate() {
-            out.add_tuple("assoc_item_list_assoc_items", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("assoc_item_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for AssocItemList {
-    fn class_name() -> &'static str { "AssocItemList" }
-}
-
-impl From<trap::Label<AssocItemList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<AssocItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocItemList>> for trap::Label<Element> {
-    fn from(value: trap::Label<AssocItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocItemList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AssocItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Attr {
-    pub id: trap::TrapId<Attr>,
-    pub meta: Option<trap::Label<Meta>>,
-}
-
-impl trap::TrapEntry for Attr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("attrs", vec![id.into()]);
-        if let Some(v) = self.meta {
-            out.add_tuple("attr_meta", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Attr {
-    fn class_name() -> &'static str { "Attr" }
-}
-
-impl From<trap::Label<Attr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Attr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Attr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Attr>> for trap::Label<Element> {
-    fn from(value: trap::Label<Attr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Attr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Attr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Callable {
-    _unused: ()
-}
-
-impl trap::TrapClass for Callable {
-    fn class_name() -> &'static str { "Callable" }
-}
-
-impl From<trap::Label<Callable>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Callable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Callable is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Callable>> for trap::Label<Element> {
-    fn from(value: trap::Label<Callable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Callable>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Callable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ClosureBinder {
-    pub id: trap::TrapId<ClosureBinder>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-}
-
-impl trap::TrapEntry for ClosureBinder {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("closure_binders", vec![id.into()]);
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("closure_binder_generic_param_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ClosureBinder {
-    fn class_name() -> &'static str { "ClosureBinder" }
-}
-
-impl From<trap::Label<ClosureBinder>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ClosureBinder>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureBinder>> for trap::Label<Element> {
-    fn from(value: trap::Label<ClosureBinder>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureBinder>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ClosureBinder>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Expr {
-    _unused: ()
-}
-
-impl trap::TrapClass for Expr {
-    fn class_name() -> &'static str { "Expr" }
-}
-
-impl From<trap::Label<Expr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Expr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Expr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Expr>> for trap::Label<Element> {
-    fn from(value: trap::Label<Expr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Expr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Expr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ExternItem {
-    _unused: ()
-}
-
-impl trap::TrapClass for ExternItem {
-    fn class_name() -> &'static str { "ExternItem" }
-}
-
-impl From<trap::Label<ExternItem>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ExternItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternItem>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExternItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternItem>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ExternItem>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ExternItemList {
-    pub id: trap::TrapId<ExternItemList>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub extern_items: Vec<trap::Label<ExternItem>>,
-}
-
-impl trap::TrapEntry for ExternItemList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("extern_item_lists", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("extern_item_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.extern_items.into_iter().enumerate() {
-            out.add_tuple("extern_item_list_extern_items", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ExternItemList {
-    fn class_name() -> &'static str { "ExternItemList" }
-}
-
-impl From<trap::Label<ExternItemList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ExternItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternItemList>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExternItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternItemList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ExternItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct FieldList {
-    _unused: ()
-}
-
-impl trap::TrapClass for FieldList {
-    fn class_name() -> &'static str { "FieldList" }
-}
-
-impl From<trap::Label<FieldList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<FieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FieldList>> for trap::Label<Element> {
-    fn from(value: trap::Label<FieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FieldList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<FieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct FormatArgsArg {
-    pub id: trap::TrapId<FormatArgsArg>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub name: Option<trap::Label<Name>>,
-}
-
-impl trap::TrapEntry for FormatArgsArg {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("format_args_args", vec![id.into()]);
-        if let Some(v) = self.expr {
-            out.add_tuple("format_args_arg_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("format_args_arg_names", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for FormatArgsArg {
-    fn class_name() -> &'static str { "FormatArgsArg" }
-}
-
-impl From<trap::Label<FormatArgsArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<FormatArgsArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FormatArgsArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<FormatArgsArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FormatArgsArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<FormatArgsArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct GenericArg {
-    _unused: ()
-}
-
-impl trap::TrapClass for GenericArg {
-    fn class_name() -> &'static str { "GenericArg" }
-}
-
-impl From<trap::Label<GenericArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<GenericArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<GenericArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<GenericArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct GenericArgList {
-    pub id: trap::TrapId<GenericArgList>,
-    pub generic_args: Vec<trap::Label<GenericArg>>,
-}
-
-impl trap::TrapEntry for GenericArgList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("generic_arg_lists", vec![id.into()]);
-        for (i, v) in self.generic_args.into_iter().enumerate() {
-            out.add_tuple("generic_arg_list_generic_args", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for GenericArgList {
-    fn class_name() -> &'static str { "GenericArgList" }
-}
-
-impl From<trap::Label<GenericArgList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<GenericArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericArgList>> for trap::Label<Element> {
-    fn from(value: trap::Label<GenericArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericArgList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<GenericArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct GenericParam {
-    _unused: ()
-}
-
-impl trap::TrapClass for GenericParam {
-    fn class_name() -> &'static str { "GenericParam" }
-}
-
-impl From<trap::Label<GenericParam>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<GenericParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericParam>> for trap::Label<Element> {
-    fn from(value: trap::Label<GenericParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericParam>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<GenericParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct GenericParamList {
-    pub id: trap::TrapId<GenericParamList>,
-    pub generic_params: Vec<trap::Label<GenericParam>>,
-}
-
-impl trap::TrapEntry for GenericParamList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("generic_param_lists", vec![id.into()]);
-        for (i, v) in self.generic_params.into_iter().enumerate() {
-            out.add_tuple("generic_param_list_generic_params", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for GenericParamList {
-    fn class_name() -> &'static str { "GenericParamList" }
-}
-
-impl From<trap::Label<GenericParamList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<GenericParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericParamList>> for trap::Label<Element> {
-    fn from(value: trap::Label<GenericParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<GenericParamList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<GenericParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ItemList {
-    pub id: trap::TrapId<ItemList>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub items: Vec<trap::Label<Item>>,
-}
-
-impl trap::TrapEntry for ItemList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("item_lists", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("item_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.items.into_iter().enumerate() {
-            out.add_tuple("item_list_items", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ItemList {
-    fn class_name() -> &'static str { "ItemList" }
-}
-
-impl From<trap::Label<ItemList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ItemList>> for trap::Label<Element> {
-    fn from(value: trap::Label<ItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ItemList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ItemList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Label {
-    pub id: trap::TrapId<Label>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-}
-
-impl trap::TrapEntry for Label {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("labels", vec![id.into()]);
-        if let Some(v) = self.lifetime {
-            out.add_tuple("label_lifetimes", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Label {
-    fn class_name() -> &'static str { "Label" }
-}
-
-impl From<trap::Label<Label>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Label>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Label is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Label>> for trap::Label<Element> {
-    fn from(value: trap::Label<Label>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Label is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Label>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Label>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Label is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LetElse {
-    pub id: trap::TrapId<LetElse>,
-    pub block_expr: Option<trap::Label<BlockExpr>>,
-}
-
-impl trap::TrapEntry for LetElse {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("let_elses", vec![id.into()]);
-        if let Some(v) = self.block_expr {
-            out.add_tuple("let_else_block_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LetElse {
-    fn class_name() -> &'static str { "LetElse" }
-}
-
-impl From<trap::Label<LetElse>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LetElse>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetElse>> for trap::Label<Element> {
-    fn from(value: trap::Label<LetElse>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetElse>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LetElse>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Lifetime {
-    pub id: trap::TrapId<Lifetime>,
-    pub text: Option<String>,
-}
-
-impl trap::TrapEntry for Lifetime {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("lifetimes", vec![id.into()]);
-        if let Some(v) = self.text {
-            out.add_tuple("lifetime_texts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Lifetime {
-    fn class_name() -> &'static str { "Lifetime" }
-}
-
-impl From<trap::Label<Lifetime>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Lifetime>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Lifetime>> for trap::Label<Element> {
-    fn from(value: trap::Label<Lifetime>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Lifetime>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Lifetime>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroItems {
-    pub id: trap::TrapId<MacroItems>,
-    pub items: Vec<trap::Label<Item>>,
-}
-
-impl trap::TrapEntry for MacroItems {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_items", vec![id.into()]);
-        for (i, v) in self.items.into_iter().enumerate() {
-            out.add_tuple("macro_items_items", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroItems {
-    fn class_name() -> &'static str { "MacroItems" }
-}
-
-impl From<trap::Label<MacroItems>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroItems>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroItems>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroItems>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroItems>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroItems>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroStmts {
-    pub id: trap::TrapId<MacroStmts>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub statements: Vec<trap::Label<Stmt>>,
-}
-
-impl trap::TrapEntry for MacroStmts {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_stmts", vec![id.into()]);
-        if let Some(v) = self.expr {
-            out.add_tuple("macro_stmts_exprs", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.statements.into_iter().enumerate() {
-            out.add_tuple("macro_stmts_statements", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroStmts {
-    fn class_name() -> &'static str { "MacroStmts" }
-}
-
-impl From<trap::Label<MacroStmts>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroStmts>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroStmts>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroStmts>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroStmts>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroStmts>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MatchArm {
-    pub id: trap::TrapId<MatchArm>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub guard: Option<trap::Label<MatchGuard>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for MatchArm {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("match_arms", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("match_arm_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("match_arm_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.guard {
-            out.add_tuple("match_arm_guards", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("match_arm_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MatchArm {
-    fn class_name() -> &'static str { "MatchArm" }
-}
-
-impl From<trap::Label<MatchArm>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MatchArm>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchArm>> for trap::Label<Element> {
-    fn from(value: trap::Label<MatchArm>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchArm>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MatchArm>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MatchArmList {
-    pub id: trap::TrapId<MatchArmList>,
-    pub arms: Vec<trap::Label<MatchArm>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for MatchArmList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("match_arm_lists", vec![id.into()]);
-        for (i, v) in self.arms.into_iter().enumerate() {
-            out.add_tuple("match_arm_list_arms", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("match_arm_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MatchArmList {
-    fn class_name() -> &'static str { "MatchArmList" }
-}
-
-impl From<trap::Label<MatchArmList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MatchArmList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchArmList>> for trap::Label<Element> {
-    fn from(value: trap::Label<MatchArmList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchArmList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MatchArmList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MatchGuard {
-    pub id: trap::TrapId<MatchGuard>,
-    pub condition: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for MatchGuard {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("match_guards", vec![id.into()]);
-        if let Some(v) = self.condition {
-            out.add_tuple("match_guard_conditions", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MatchGuard {
-    fn class_name() -> &'static str { "MatchGuard" }
-}
-
-impl From<trap::Label<MatchGuard>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MatchGuard>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchGuard>> for trap::Label<Element> {
-    fn from(value: trap::Label<MatchGuard>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchGuard>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MatchGuard>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Meta {
-    pub id: trap::TrapId<Meta>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub is_unsafe: bool,
-    pub path: Option<trap::Label<Path>>,
-    pub token_tree: Option<trap::Label<TokenTree>>,
-}
-
-impl trap::TrapEntry for Meta {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("meta", vec![id.into()]);
-        if let Some(v) = self.expr {
-            out.add_tuple("meta_exprs", vec![id.into(), v.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("meta_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.path {
-            out.add_tuple("meta_paths", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.token_tree {
-            out.add_tuple("meta_token_trees", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Meta {
-    fn class_name() -> &'static str { "Meta" }
-}
-
-impl From<trap::Label<Meta>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Meta>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Meta is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Meta>> for trap::Label<Element> {
-    fn from(value: trap::Label<Meta>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Meta>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Meta>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Name {
-    pub id: trap::TrapId<Name>,
-    pub text: Option<String>,
-}
-
-impl trap::TrapEntry for Name {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("names", vec![id.into()]);
-        if let Some(v) = self.text {
-            out.add_tuple("name_texts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Name {
-    fn class_name() -> &'static str { "Name" }
-}
-
-impl From<trap::Label<Name>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Name>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Name is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Name>> for trap::Label<Element> {
-    fn from(value: trap::Label<Name>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Name is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Name>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Name>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Name is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct NameRef {
-    pub id: trap::TrapId<NameRef>,
-    pub text: Option<String>,
-}
-
-impl trap::TrapEntry for NameRef {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("name_refs", vec![id.into()]);
-        if let Some(v) = self.text {
-            out.add_tuple("name_ref_texts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for NameRef {
-    fn class_name() -> &'static str { "NameRef" }
-}
-
-impl From<trap::Label<NameRef>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<NameRef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<NameRef>> for trap::Label<Element> {
-    fn from(value: trap::Label<NameRef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<NameRef>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<NameRef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ParamBase {
-    _unused: ()
-}
-
-impl trap::TrapClass for ParamBase {
-    fn class_name() -> &'static str { "ParamBase" }
-}
-
-impl From<trap::Label<ParamBase>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ParamBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParamBase>> for trap::Label<Element> {
-    fn from(value: trap::Label<ParamBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParamBase>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ParamBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ParamList {
-    pub id: trap::TrapId<ParamList>,
-    pub params: Vec<trap::Label<Param>>,
-    pub self_param: Option<trap::Label<SelfParam>>,
-}
-
-impl trap::TrapEntry for ParamList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("param_lists", vec![id.into()]);
-        for (i, v) in self.params.into_iter().enumerate() {
-            out.add_tuple("param_list_params", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.self_param {
-            out.add_tuple("param_list_self_params", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ParamList {
-    fn class_name() -> &'static str { "ParamList" }
-}
-
-impl From<trap::Label<ParamList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParamList>> for trap::Label<Element> {
-    fn from(value: trap::Label<ParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParamList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ParamList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Pat {
-    _unused: ()
-}
-
-impl trap::TrapClass for Pat {
-    fn class_name() -> &'static str { "Pat" }
-}
-
-impl From<trap::Label<Pat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Pat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Pat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Pat>> for trap::Label<Element> {
-    fn from(value: trap::Label<Pat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Pat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Pat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Path {
-    pub id: trap::TrapId<Path>,
-    pub qualifier: Option<trap::Label<Path>>,
-    pub part: Option<trap::Label<PathSegment>>,
-}
-
-impl trap::TrapEntry for Path {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("paths", vec![id.into()]);
-        if let Some(v) = self.qualifier {
-            out.add_tuple("path_qualifiers", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.part {
-            out.add_tuple("path_parts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Path {
-    fn class_name() -> &'static str { "Path" }
-}
-
-impl From<trap::Label<Path>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Path>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Path is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Path>> for trap::Label<Element> {
-    fn from(value: trap::Label<Path>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Path is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Path>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Path>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Path is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathSegment {
-    pub id: trap::TrapId<PathSegment>,
-    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-    pub param_list: Option<trap::Label<ParamList>>,
-    pub path_type: Option<trap::Label<PathTypeRepr>>,
-    pub ret_type: Option<trap::Label<RetTypeRepr>>,
-    pub return_type_syntax: Option<trap::Label<ReturnTypeSyntax>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for PathSegment {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("path_segments", vec![id.into()]);
-        if let Some(v) = self.generic_arg_list {
-            out.add_tuple("path_segment_generic_arg_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("path_segment_name_refs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.param_list {
-            out.add_tuple("path_segment_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.path_type {
-            out.add_tuple("path_segment_path_types", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.ret_type {
-            out.add_tuple("path_segment_ret_types", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.return_type_syntax {
-            out.add_tuple("path_segment_return_type_syntaxes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("path_segment_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PathSegment {
-    fn class_name() -> &'static str { "PathSegment" }
-}
-
-impl From<trap::Label<PathSegment>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathSegment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathSegment>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathSegment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathSegment>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathSegment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordExprField {
-    pub id: trap::TrapId<RecordExprField>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-}
-
-impl trap::TrapEntry for RecordExprField {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_expr_fields", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("record_expr_field_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("record_expr_field_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("record_expr_field_name_refs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordExprField {
-    fn class_name() -> &'static str { "RecordExprField" }
-}
-
-impl From<trap::Label<RecordExprField>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordExprField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExprField>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordExprField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExprField>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordExprField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprField is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordExprFieldList {
-    pub id: trap::TrapId<RecordExprFieldList>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub fields: Vec<trap::Label<RecordExprField>>,
-    pub spread: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for RecordExprFieldList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_expr_field_lists", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("record_expr_field_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("record_expr_field_list_fields", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.spread {
-            out.add_tuple("record_expr_field_list_spreads", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordExprFieldList {
-    fn class_name() -> &'static str { "RecordExprFieldList" }
-}
-
-impl From<trap::Label<RecordExprFieldList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExprFieldList>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExprFieldList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordExprFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExprFieldList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordField {
-    pub id: trap::TrapId<RecordField>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub name: Option<trap::Label<Name>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for RecordField {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_fields", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("record_field_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("record_field_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("record_field_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("record_field_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordField {
-    fn class_name() -> &'static str { "RecordField" }
-}
-
-impl From<trap::Label<RecordField>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordField>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordField>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordField is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordPatField {
-    pub id: trap::TrapId<RecordPatField>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for RecordPatField {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_pat_fields", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("record_pat_field_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("record_pat_field_name_refs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("record_pat_field_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordPatField {
-    fn class_name() -> &'static str { "RecordPatField" }
-}
-
-impl From<trap::Label<RecordPatField>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordPatField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPatField>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordPatField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPatField>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordPatField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatField is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordPatFieldList {
-    pub id: trap::TrapId<RecordPatFieldList>,
-    pub fields: Vec<trap::Label<RecordPatField>>,
-    pub rest_pat: Option<trap::Label<RestPat>>,
-}
-
-impl trap::TrapEntry for RecordPatFieldList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_pat_field_lists", vec![id.into()]);
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("record_pat_field_list_fields", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.rest_pat {
-            out.add_tuple("record_pat_field_list_rest_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordPatFieldList {
-    fn class_name() -> &'static str { "RecordPatFieldList" }
-}
-
-impl From<trap::Label<RecordPatFieldList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPatFieldList>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPatFieldList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordPatFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPatFieldList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Rename {
-    pub id: trap::TrapId<Rename>,
-    pub name: Option<trap::Label<Name>>,
-}
-
-impl trap::TrapEntry for Rename {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("renames", vec![id.into()]);
-        if let Some(v) = self.name {
-            out.add_tuple("rename_names", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Rename {
-    fn class_name() -> &'static str { "Rename" }
-}
-
-impl From<trap::Label<Rename>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Rename>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Rename is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Rename>> for trap::Label<Element> {
-    fn from(value: trap::Label<Rename>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Rename>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Rename>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Resolvable {
-    _unused: ()
-}
-
-impl Resolvable {
-    pub fn emit_resolved_path(id: trap::Label<Self>, value: String, out: &mut trap::Writer) {
-        out.add_tuple("resolvable_resolved_paths", vec![id.into(), value.into()]);
-    }
-    pub fn emit_resolved_crate_origin(id: trap::Label<Self>, value: String, out: &mut trap::Writer) {
-        out.add_tuple("resolvable_resolved_crate_origins", vec![id.into(), value.into()]);
-    }
-}
-
-impl trap::TrapClass for Resolvable {
-    fn class_name() -> &'static str { "Resolvable" }
-}
-
-impl From<trap::Label<Resolvable>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Resolvable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Resolvable>> for trap::Label<Element> {
-    fn from(value: trap::Label<Resolvable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Resolvable>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Resolvable>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RetTypeRepr {
-    pub id: trap::TrapId<RetTypeRepr>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for RetTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ret_type_reprs", vec![id.into()]);
-        if let Some(v) = self.type_repr {
-            out.add_tuple("ret_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RetTypeRepr {
-    fn class_name() -> &'static str { "RetTypeRepr" }
-}
-
-impl From<trap::Label<RetTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RetTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RetTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<RetTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RetTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RetTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ReturnTypeSyntax {
-    pub id: trap::TrapId<ReturnTypeSyntax>,
-}
-
-impl trap::TrapEntry for ReturnTypeSyntax {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("return_type_syntaxes", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for ReturnTypeSyntax {
-    fn class_name() -> &'static str { "ReturnTypeSyntax" }
-}
-
-impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Element> {
-    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ReturnTypeSyntax>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SourceFile {
-    pub id: trap::TrapId<SourceFile>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub items: Vec<trap::Label<Item>>,
-}
-
-impl trap::TrapEntry for SourceFile {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("source_files", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("source_file_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.items.into_iter().enumerate() {
-            out.add_tuple("source_file_items", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for SourceFile {
-    fn class_name() -> &'static str { "SourceFile" }
-}
-
-impl From<trap::Label<SourceFile>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<SourceFile>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SourceFile>> for trap::Label<Element> {
-    fn from(value: trap::Label<SourceFile>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SourceFile>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<SourceFile>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Stmt {
-    _unused: ()
-}
-
-impl trap::TrapClass for Stmt {
-    fn class_name() -> &'static str { "Stmt" }
-}
-
-impl From<trap::Label<Stmt>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Stmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Stmt>> for trap::Label<Element> {
-    fn from(value: trap::Label<Stmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Stmt>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Stmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct StmtList {
-    pub id: trap::TrapId<StmtList>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub statements: Vec<trap::Label<Stmt>>,
-    pub tail_expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for StmtList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("stmt_lists", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("stmt_list_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.statements.into_iter().enumerate() {
-            out.add_tuple("stmt_list_statements", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.tail_expr {
-            out.add_tuple("stmt_list_tail_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for StmtList {
-    fn class_name() -> &'static str { "StmtList" }
-}
-
-impl From<trap::Label<StmtList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<StmtList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<StmtList>> for trap::Label<Element> {
-    fn from(value: trap::Label<StmtList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<StmtList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<StmtList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Token {
-    _unused: ()
-}
-
-impl trap::TrapClass for Token {
-    fn class_name() -> &'static str { "Token" }
-}
-
-impl From<trap::Label<Token>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Token>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Token is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Token>> for trap::Label<Element> {
-    fn from(value: trap::Label<Token>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Token is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Token>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Token>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Token is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TokenTree {
-    pub id: trap::TrapId<TokenTree>,
-}
-
-impl trap::TrapEntry for TokenTree {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("token_trees", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for TokenTree {
-    fn class_name() -> &'static str { "TokenTree" }
-}
-
-impl From<trap::Label<TokenTree>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TokenTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TokenTree>> for trap::Label<Element> {
-    fn from(value: trap::Label<TokenTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TokenTree>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TokenTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TupleField {
-    pub id: trap::TrapId<TupleField>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for TupleField {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_fields", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("tuple_field_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("tuple_field_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("tuple_field_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TupleField {
-    fn class_name() -> &'static str { "TupleField" }
-}
-
-impl From<trap::Label<TupleField>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TupleField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleField>> for trap::Label<Element> {
-    fn from(value: trap::Label<TupleField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleField>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TupleField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeBound {
-    pub id: trap::TrapId<TypeBound>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub is_async: bool,
-    pub is_const: bool,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for TypeBound {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("type_bounds", vec![id.into()]);
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("type_bound_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_async {
-            out.add_tuple("type_bound_is_async", vec![id.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("type_bound_is_const", vec![id.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("type_bound_lifetimes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("type_bound_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TypeBound {
-    fn class_name() -> &'static str { "TypeBound" }
-}
-
-impl From<trap::Label<TypeBound>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeBound>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeBound>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeBound>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeBound>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeBound>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeBoundList {
-    pub id: trap::TrapId<TypeBoundList>,
-    pub bounds: Vec<trap::Label<TypeBound>>,
-}
-
-impl trap::TrapEntry for TypeBoundList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("type_bound_lists", vec![id.into()]);
-        for (i, v) in self.bounds.into_iter().enumerate() {
-            out.add_tuple("type_bound_list_bounds", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TypeBoundList {
-    fn class_name() -> &'static str { "TypeBoundList" }
-}
-
-impl From<trap::Label<TypeBoundList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeBoundList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeBoundList>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeBoundList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeBoundList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeBoundList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeRepr {
-    _unused: ()
-}
-
-impl trap::TrapClass for TypeRepr {
-    fn class_name() -> &'static str { "TypeRepr" }
-}
-
-impl From<trap::Label<TypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct UseTree {
-    pub id: trap::TrapId<UseTree>,
-    pub path: Option<trap::Label<Path>>,
-    pub rename: Option<trap::Label<Rename>>,
-    pub use_tree_list: Option<trap::Label<UseTreeList>>,
-}
-
-impl trap::TrapEntry for UseTree {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("use_trees", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("use_tree_paths", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.rename {
-            out.add_tuple("use_tree_renames", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.use_tree_list {
-            out.add_tuple("use_tree_use_tree_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for UseTree {
-    fn class_name() -> &'static str { "UseTree" }
-}
-
-impl From<trap::Label<UseTree>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<UseTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UseTree>> for trap::Label<Element> {
-    fn from(value: trap::Label<UseTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UseTree>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<UseTree>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct UseTreeList {
-    pub id: trap::TrapId<UseTreeList>,
-    pub use_trees: Vec<trap::Label<UseTree>>,
-}
-
-impl trap::TrapEntry for UseTreeList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("use_tree_lists", vec![id.into()]);
-        for (i, v) in self.use_trees.into_iter().enumerate() {
-            out.add_tuple("use_tree_list_use_trees", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for UseTreeList {
-    fn class_name() -> &'static str { "UseTreeList" }
-}
-
-impl From<trap::Label<UseTreeList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<UseTreeList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UseTreeList>> for trap::Label<Element> {
-    fn from(value: trap::Label<UseTreeList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UseTreeList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<UseTreeList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct VariantList {
-    pub id: trap::TrapId<VariantList>,
-    pub variants: Vec<trap::Label<Variant>>,
-}
-
-impl trap::TrapEntry for VariantList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("variant_lists", vec![id.into()]);
-        for (i, v) in self.variants.into_iter().enumerate() {
-            out.add_tuple("variant_list_variants", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for VariantList {
-    fn class_name() -> &'static str { "VariantList" }
-}
-
-impl From<trap::Label<VariantList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<VariantList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<VariantList>> for trap::Label<Element> {
-    fn from(value: trap::Label<VariantList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<VariantList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<VariantList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Visibility {
-    pub id: trap::TrapId<Visibility>,
-    pub path: Option<trap::Label<Path>>,
-}
-
-impl trap::TrapEntry for Visibility {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("visibilities", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("visibility_paths", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Visibility {
-    fn class_name() -> &'static str { "Visibility" }
-}
-
-impl From<trap::Label<Visibility>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Visibility>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Visibility>> for trap::Label<Element> {
-    fn from(value: trap::Label<Visibility>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Visibility>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Visibility>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct WhereClause {
-    pub id: trap::TrapId<WhereClause>,
-    pub predicates: Vec<trap::Label<WherePred>>,
-}
-
-impl trap::TrapEntry for WhereClause {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("where_clauses", vec![id.into()]);
-        for (i, v) in self.predicates.into_iter().enumerate() {
-            out.add_tuple("where_clause_predicates", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for WhereClause {
-    fn class_name() -> &'static str { "WhereClause" }
-}
-
-impl From<trap::Label<WhereClause>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<WhereClause>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhereClause>> for trap::Label<Element> {
-    fn from(value: trap::Label<WhereClause>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhereClause>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<WhereClause>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct WherePred {
-    pub id: trap::TrapId<WherePred>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for WherePred {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("where_preds", vec![id.into()]);
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("where_pred_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("where_pred_lifetimes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("where_pred_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("where_pred_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for WherePred {
-    fn class_name() -> &'static str { "WherePred" }
-}
-
-impl From<trap::Label<WherePred>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<WherePred>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WherePred>> for trap::Label<Element> {
-    fn from(value: trap::Label<WherePred>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WherePred>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<WherePred>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ArrayExprInternal {
-    pub id: trap::TrapId<ArrayExprInternal>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub exprs: Vec<trap::Label<Expr>>,
-    pub is_semicolon: bool,
-}
-
-impl trap::TrapEntry for ArrayExprInternal {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("array_expr_internals", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("array_expr_internal_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.exprs.into_iter().enumerate() {
-            out.add_tuple("array_expr_internal_exprs", vec![id.into(), i.into(), v.into()]);
-        }
-        if self.is_semicolon {
-            out.add_tuple("array_expr_internal_is_semicolon", vec![id.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ArrayExprInternal {
-    fn class_name() -> &'static str { "ArrayExprInternal" }
-}
-
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<Element> {
-    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ArrayExprInternal>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ArrayTypeRepr {
-    pub id: trap::TrapId<ArrayTypeRepr>,
-    pub const_arg: Option<trap::Label<ConstArg>>,
-    pub element_type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for ArrayTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("array_type_reprs", vec![id.into()]);
-        if let Some(v) = self.const_arg {
-            out.add_tuple("array_type_repr_const_args", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.element_type_repr {
-            out.add_tuple("array_type_repr_element_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ArrayTypeRepr {
-    fn class_name() -> &'static str { "ArrayTypeRepr" }
-}
-
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<ArrayTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AsmExpr {
-    pub id: trap::TrapId<AsmExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for AsmExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("asm_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("asm_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("asm_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for AsmExpr {
-    fn class_name() -> &'static str { "AsmExpr" }
-}
-
-impl From<trap::Label<AsmExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<AsmExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AsmExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<AsmExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AsmExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<AsmExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AsmExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AsmExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AssocTypeArg {
-    pub id: trap::TrapId<AssocTypeArg>,
-    pub const_arg: Option<trap::Label<ConstArg>>,
-    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-    pub param_list: Option<trap::Label<ParamList>>,
-    pub ret_type: Option<trap::Label<RetTypeRepr>>,
-    pub return_type_syntax: Option<trap::Label<ReturnTypeSyntax>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for AssocTypeArg {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("assoc_type_args", vec![id.into()]);
-        if let Some(v) = self.const_arg {
-            out.add_tuple("assoc_type_arg_const_args", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_arg_list {
-            out.add_tuple("assoc_type_arg_generic_arg_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("assoc_type_arg_name_refs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.param_list {
-            out.add_tuple("assoc_type_arg_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.ret_type {
-            out.add_tuple("assoc_type_arg_ret_types", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.return_type_syntax {
-            out.add_tuple("assoc_type_arg_return_type_syntaxes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("assoc_type_arg_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("assoc_type_arg_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for AssocTypeArg {
-    fn class_name() -> &'static str { "AssocTypeArg" }
-}
-
-impl From<trap::Label<AssocTypeArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<AssocTypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocTypeArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<AssocTypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocTypeArg>> for trap::Label<GenericArg> {
-    fn from(value: trap::Label<AssocTypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of GenericArg
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AssocTypeArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AssocTypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AwaitExpr {
-    pub id: trap::TrapId<AwaitExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for AwaitExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("await_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("await_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("await_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for AwaitExpr {
-    fn class_name() -> &'static str { "AwaitExpr" }
-}
-
-impl From<trap::Label<AwaitExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<AwaitExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AwaitExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<AwaitExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AwaitExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<AwaitExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<AwaitExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<AwaitExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct BecomeExpr {
-    pub id: trap::TrapId<BecomeExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for BecomeExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("become_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("become_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("become_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for BecomeExpr {
-    fn class_name() -> &'static str { "BecomeExpr" }
-}
-
-impl From<trap::Label<BecomeExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<BecomeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BecomeExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<BecomeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BecomeExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<BecomeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BecomeExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<BecomeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct BinaryExpr {
-    pub id: trap::TrapId<BinaryExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub lhs: Option<trap::Label<Expr>>,
-    pub operator_name: Option<String>,
-    pub rhs: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for BinaryExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("binary_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("binary_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.lhs {
-            out.add_tuple("binary_expr_lhs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.operator_name {
-            out.add_tuple("binary_expr_operator_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.rhs {
-            out.add_tuple("binary_expr_rhs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for BinaryExpr {
-    fn class_name() -> &'static str { "BinaryExpr" }
-}
-
-impl From<trap::Label<BinaryExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<BinaryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BinaryExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<BinaryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BinaryExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<BinaryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BinaryExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<BinaryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct BoxPat {
-    pub id: trap::TrapId<BoxPat>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for BoxPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("box_pats", vec![id.into()]);
-        if let Some(v) = self.pat {
-            out.add_tuple("box_pat_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for BoxPat {
-    fn class_name() -> &'static str { "BoxPat" }
-}
-
-impl From<trap::Label<BoxPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<BoxPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BoxPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<BoxPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BoxPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<BoxPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BoxPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<BoxPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct BreakExpr {
-    pub id: trap::TrapId<BreakExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-}
-
-impl trap::TrapEntry for BreakExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("break_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("break_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("break_expr_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("break_expr_lifetimes", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for BreakExpr {
-    fn class_name() -> &'static str { "BreakExpr" }
-}
-
-impl From<trap::Label<BreakExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<BreakExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BreakExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<BreakExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BreakExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<BreakExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BreakExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<BreakExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct CallExprBase {
-    _unused: ()
-}
-
-impl trap::TrapClass for CallExprBase {
-    fn class_name() -> &'static str { "CallExprBase" }
-}
-
-impl From<trap::Label<CallExprBase>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<CallExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExprBase>> for trap::Label<Element> {
-    fn from(value: trap::Label<CallExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExprBase>> for trap::Label<Expr> {
-    fn from(value: trap::Label<CallExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExprBase>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<CallExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct CastExpr {
-    pub id: trap::TrapId<CastExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for CastExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("cast_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("cast_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("cast_expr_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("cast_expr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for CastExpr {
-    fn class_name() -> &'static str { "CastExpr" }
-}
-
-impl From<trap::Label<CastExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<CastExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CastExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<CastExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CastExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<CastExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CastExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<CastExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ClosureExpr {
-    pub id: trap::TrapId<ClosureExpr>,
-    pub param_list: Option<trap::Label<ParamList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub body: Option<trap::Label<Expr>>,
-    pub closure_binder: Option<trap::Label<ClosureBinder>>,
-    pub is_async: bool,
-    pub is_const: bool,
-    pub is_gen: bool,
-    pub is_move: bool,
-    pub is_static: bool,
-    pub ret_type: Option<trap::Label<RetTypeRepr>>,
-}
-
-impl trap::TrapEntry for ClosureExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("closure_exprs", vec![id.into()]);
-        if let Some(v) = self.param_list {
-            out.add_tuple("callable_param_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("callable_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.body {
-            out.add_tuple("closure_expr_bodies", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.closure_binder {
-            out.add_tuple("closure_expr_closure_binders", vec![id.into(), v.into()]);
-        }
-        if self.is_async {
-            out.add_tuple("closure_expr_is_async", vec![id.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("closure_expr_is_const", vec![id.into()]);
-        }
-        if self.is_gen {
-            out.add_tuple("closure_expr_is_gen", vec![id.into()]);
-        }
-        if self.is_move {
-            out.add_tuple("closure_expr_is_move", vec![id.into()]);
-        }
-        if self.is_static {
-            out.add_tuple("closure_expr_is_static", vec![id.into()]);
-        }
-        if let Some(v) = self.ret_type {
-            out.add_tuple("closure_expr_ret_types", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ClosureExpr {
-    fn class_name() -> &'static str { "ClosureExpr" }
-}
-
-impl From<trap::Label<ClosureExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureExpr>> for trap::Label<Callable> {
-    fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Callable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ClosureExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Comment {
-    pub id: trap::TrapId<Comment>,
-    pub parent: trap::Label<AstNode>,
-    pub text: String,
-}
-
-impl trap::TrapEntry for Comment {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("comments", vec![id.into(), self.parent.into(), self.text.into()]);
-    }
-}
-
-impl trap::TrapClass for Comment {
-    fn class_name() -> &'static str { "Comment" }
-}
-
-impl From<trap::Label<Comment>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Comment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Comment is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Comment>> for trap::Label<Element> {
-    fn from(value: trap::Label<Comment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Comment>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Comment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Comment>> for trap::Label<Token> {
-    fn from(value: trap::Label<Comment>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Token
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ConstArg {
-    pub id: trap::TrapId<ConstArg>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for ConstArg {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("const_args", vec![id.into()]);
-        if let Some(v) = self.expr {
-            out.add_tuple("const_arg_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ConstArg {
-    fn class_name() -> &'static str { "ConstArg" }
-}
-
-impl From<trap::Label<ConstArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ConstArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<ConstArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstArg>> for trap::Label<GenericArg> {
-    fn from(value: trap::Label<ConstArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of GenericArg
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ConstArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ConstBlockPat {
-    pub id: trap::TrapId<ConstBlockPat>,
-    pub block_expr: Option<trap::Label<BlockExpr>>,
-    pub is_const: bool,
-}
-
-impl trap::TrapEntry for ConstBlockPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("const_block_pats", vec![id.into()]);
-        if let Some(v) = self.block_expr {
-            out.add_tuple("const_block_pat_block_exprs", vec![id.into(), v.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("const_block_pat_is_const", vec![id.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ConstBlockPat {
-    fn class_name() -> &'static str { "ConstBlockPat" }
-}
-
-impl From<trap::Label<ConstBlockPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ConstBlockPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstBlockPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<ConstBlockPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstBlockPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ConstBlockPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstBlockPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<ConstBlockPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ConstParam {
-    pub id: trap::TrapId<ConstParam>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub default_val: Option<trap::Label<ConstArg>>,
-    pub is_const: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for ConstParam {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("const_params", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("const_param_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.default_val {
-            out.add_tuple("const_param_default_vals", vec![id.into(), v.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("const_param_is_const", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("const_param_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("const_param_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ConstParam {
-    fn class_name() -> &'static str { "ConstParam" }
-}
-
-impl From<trap::Label<ConstParam>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ConstParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstParam>> for trap::Label<Element> {
-    fn from(value: trap::Label<ConstParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstParam>> for trap::Label<GenericParam> {
-    fn from(value: trap::Label<ConstParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of GenericParam
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ConstParam>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ConstParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ContinueExpr {
-    pub id: trap::TrapId<ContinueExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-}
-
-impl trap::TrapEntry for ContinueExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("continue_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("continue_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("continue_expr_lifetimes", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ContinueExpr {
-    fn class_name() -> &'static str { "ContinueExpr" }
-}
-
-impl From<trap::Label<ContinueExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ContinueExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ContinueExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ContinueExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ContinueExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ContinueExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ContinueExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ContinueExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct DynTraitTypeRepr {
-    pub id: trap::TrapId<DynTraitTypeRepr>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for DynTraitTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("dyn_trait_type_reprs", vec![id.into()]);
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("dyn_trait_type_repr_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for DynTraitTypeRepr {
-    fn class_name() -> &'static str { "DynTraitTypeRepr" }
-}
-
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<DynTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ExprStmt {
-    pub id: trap::TrapId<ExprStmt>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for ExprStmt {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("expr_stmts", vec![id.into()]);
-        if let Some(v) = self.expr {
-            out.add_tuple("expr_stmt_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ExprStmt {
-    fn class_name() -> &'static str { "ExprStmt" }
-}
-
-impl From<trap::Label<ExprStmt>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ExprStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExprStmt>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExprStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExprStmt>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ExprStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExprStmt>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<ExprStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct FieldExpr {
-    pub id: trap::TrapId<FieldExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-}
-
-impl trap::TrapEntry for FieldExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("field_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("field_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("field_expr_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("field_expr_name_refs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for FieldExpr {
-    fn class_name() -> &'static str { "FieldExpr" }
-}
-
-impl From<trap::Label<FieldExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<FieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FieldExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<FieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FieldExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<FieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FieldExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<FieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct FnPtrTypeRepr {
-    pub id: trap::TrapId<FnPtrTypeRepr>,
-    pub abi: Option<trap::Label<Abi>>,
-    pub is_async: bool,
-    pub is_const: bool,
-    pub is_unsafe: bool,
-    pub param_list: Option<trap::Label<ParamList>>,
-    pub ret_type: Option<trap::Label<RetTypeRepr>>,
-}
-
-impl trap::TrapEntry for FnPtrTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("fn_ptr_type_reprs", vec![id.into()]);
-        if let Some(v) = self.abi {
-            out.add_tuple("fn_ptr_type_repr_abis", vec![id.into(), v.into()]);
-        }
-        if self.is_async {
-            out.add_tuple("fn_ptr_type_repr_is_async", vec![id.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("fn_ptr_type_repr_is_const", vec![id.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("fn_ptr_type_repr_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.param_list {
-            out.add_tuple("fn_ptr_type_repr_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.ret_type {
-            out.add_tuple("fn_ptr_type_repr_ret_types", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for FnPtrTypeRepr {
-    fn class_name() -> &'static str { "FnPtrTypeRepr" }
-}
-
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<FnPtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ForTypeRepr {
-    pub id: trap::TrapId<ForTypeRepr>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for ForTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("for_type_reprs", vec![id.into()]);
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("for_type_repr_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("for_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ForTypeRepr {
-    fn class_name() -> &'static str { "ForTypeRepr" }
-}
-
-impl From<trap::Label<ForTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ForTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ForTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ForTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<ForTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct FormatArgsExpr {
-    pub id: trap::TrapId<FormatArgsExpr>,
-    pub args: Vec<trap::Label<FormatArgsArg>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub template: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for FormatArgsExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("format_args_exprs", vec![id.into()]);
-        for (i, v) in self.args.into_iter().enumerate() {
-            out.add_tuple("format_args_expr_args", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("format_args_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.template {
-            out.add_tuple("format_args_expr_templates", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for FormatArgsExpr {
-    fn class_name() -> &'static str { "FormatArgsExpr" }
-}
-
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<FormatArgsExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct IdentPat {
-    pub id: trap::TrapId<IdentPat>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub is_mut: bool,
-    pub is_ref: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for IdentPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ident_pats", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("ident_pat_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if self.is_mut {
-            out.add_tuple("ident_pat_is_mut", vec![id.into()]);
-        }
-        if self.is_ref {
-            out.add_tuple("ident_pat_is_ref", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("ident_pat_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("ident_pat_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for IdentPat {
-    fn class_name() -> &'static str { "IdentPat" }
-}
-
-impl From<trap::Label<IdentPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<IdentPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IdentPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<IdentPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IdentPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<IdentPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IdentPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<IdentPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct IfExpr {
-    pub id: trap::TrapId<IfExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub condition: Option<trap::Label<Expr>>,
-    pub else_: Option<trap::Label<Expr>>,
-    pub then: Option<trap::Label<BlockExpr>>,
-}
-
-impl trap::TrapEntry for IfExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("if_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("if_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.condition {
-            out.add_tuple("if_expr_conditions", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.else_ {
-            out.add_tuple("if_expr_elses", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.then {
-            out.add_tuple("if_expr_thens", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for IfExpr {
-    fn class_name() -> &'static str { "IfExpr" }
-}
-
-impl From<trap::Label<IfExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<IfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IfExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<IfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IfExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<IfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IfExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<IfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ImplTraitTypeRepr {
-    pub id: trap::TrapId<ImplTraitTypeRepr>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for ImplTraitTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("impl_trait_type_reprs", vec![id.into()]);
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("impl_trait_type_repr_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ImplTraitTypeRepr {
-    fn class_name() -> &'static str { "ImplTraitTypeRepr" }
-}
-
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<ImplTraitTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct IndexExpr {
-    pub id: trap::TrapId<IndexExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub base: Option<trap::Label<Expr>>,
-    pub index: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for IndexExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("index_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("index_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.base {
-            out.add_tuple("index_expr_bases", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.index {
-            out.add_tuple("index_expr_indices", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for IndexExpr {
-    fn class_name() -> &'static str { "IndexExpr" }
-}
-
-impl From<trap::Label<IndexExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<IndexExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IndexExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<IndexExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IndexExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<IndexExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<IndexExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<IndexExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct InferTypeRepr {
-    pub id: trap::TrapId<InferTypeRepr>,
-}
-
-impl trap::TrapEntry for InferTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("infer_type_reprs", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for InferTypeRepr {
-    fn class_name() -> &'static str { "InferTypeRepr" }
-}
-
-impl From<trap::Label<InferTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<InferTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<InferTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<InferTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<InferTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<InferTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<InferTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<InferTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Item {
-    _unused: ()
-}
-
-impl trap::TrapClass for Item {
-    fn class_name() -> &'static str { "Item" }
-}
-
-impl From<trap::Label<Item>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Item>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Item is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Item>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Item>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Item is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Item>> for trap::Label<Element> {
-    fn from(value: trap::Label<Item>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Item is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Item>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Item>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Item is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Item>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Item>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Item is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LabelableExpr {
-    _unused: ()
-}
-
-impl trap::TrapClass for LabelableExpr {
-    fn class_name() -> &'static str { "LabelableExpr" }
-}
-
-impl From<trap::Label<LabelableExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LabelableExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LabelableExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<LabelableExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LabelableExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<LabelableExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LabelableExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LabelableExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LetExpr {
-    pub id: trap::TrapId<LetExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub scrutinee: Option<trap::Label<Expr>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for LetExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("let_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("let_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.scrutinee {
-            out.add_tuple("let_expr_scrutinees", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("let_expr_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LetExpr {
-    fn class_name() -> &'static str { "LetExpr" }
-}
-
-impl From<trap::Label<LetExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<LetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<LetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LetStmt {
-    pub id: trap::TrapId<LetStmt>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub initializer: Option<trap::Label<Expr>>,
-    pub let_else: Option<trap::Label<LetElse>>,
-    pub pat: Option<trap::Label<Pat>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for LetStmt {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("let_stmts", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("let_stmt_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.initializer {
-            out.add_tuple("let_stmt_initializers", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.let_else {
-            out.add_tuple("let_stmt_let_elses", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("let_stmt_pats", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("let_stmt_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LetStmt {
-    fn class_name() -> &'static str { "LetStmt" }
-}
-
-impl From<trap::Label<LetStmt>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LetStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetStmt>> for trap::Label<Element> {
-    fn from(value: trap::Label<LetStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetStmt>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LetStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LetStmt>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<LetStmt>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LifetimeArg {
-    pub id: trap::TrapId<LifetimeArg>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-}
-
-impl trap::TrapEntry for LifetimeArg {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("lifetime_args", vec![id.into()]);
-        if let Some(v) = self.lifetime {
-            out.add_tuple("lifetime_arg_lifetimes", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LifetimeArg {
-    fn class_name() -> &'static str { "LifetimeArg" }
-}
-
-impl From<trap::Label<LifetimeArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LifetimeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<LifetimeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeArg>> for trap::Label<GenericArg> {
-    fn from(value: trap::Label<LifetimeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of GenericArg
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LifetimeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LifetimeParam {
-    pub id: trap::TrapId<LifetimeParam>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for LifetimeParam {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("lifetime_params", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("lifetime_param_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("lifetime_param_lifetimes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("lifetime_param_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LifetimeParam {
-    fn class_name() -> &'static str { "LifetimeParam" }
-}
-
-impl From<trap::Label<LifetimeParam>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LifetimeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeParam>> for trap::Label<Element> {
-    fn from(value: trap::Label<LifetimeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeParam>> for trap::Label<GenericParam> {
-    fn from(value: trap::Label<LifetimeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of GenericParam
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LifetimeParam>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LifetimeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LiteralExpr {
-    pub id: trap::TrapId<LiteralExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub text_value: Option<String>,
-}
-
-impl trap::TrapEntry for LiteralExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("literal_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("literal_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.text_value {
-            out.add_tuple("literal_expr_text_values", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LiteralExpr {
-    fn class_name() -> &'static str { "LiteralExpr" }
-}
-
-impl From<trap::Label<LiteralExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LiteralExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<LiteralExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<LiteralExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LiteralExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LiteralPat {
-    pub id: trap::TrapId<LiteralPat>,
-    pub literal: Option<trap::Label<LiteralExpr>>,
-}
-
-impl trap::TrapEntry for LiteralPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("literal_pats", vec![id.into()]);
-        if let Some(v) = self.literal {
-            out.add_tuple("literal_pat_literals", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LiteralPat {
-    fn class_name() -> &'static str { "LiteralPat" }
-}
-
-impl From<trap::Label<LiteralPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LiteralPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<LiteralPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LiteralPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LiteralPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<LiteralPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroExpr {
-    pub id: trap::TrapId<MacroExpr>,
-    pub macro_call: Option<trap::Label<MacroCall>>,
-}
-
-impl trap::TrapEntry for MacroExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_exprs", vec![id.into()]);
-        if let Some(v) = self.macro_call {
-            out.add_tuple("macro_expr_macro_calls", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroExpr {
-    fn class_name() -> &'static str { "MacroExpr" }
-}
-
-impl From<trap::Label<MacroExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<MacroExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroPat {
-    pub id: trap::TrapId<MacroPat>,
-    pub macro_call: Option<trap::Label<MacroCall>>,
-}
-
-impl trap::TrapEntry for MacroPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_pats", vec![id.into()]);
-        if let Some(v) = self.macro_call {
-            out.add_tuple("macro_pat_macro_calls", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroPat {
-    fn class_name() -> &'static str { "MacroPat" }
-}
-
-impl From<trap::Label<MacroPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<MacroPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroTypeRepr {
-    pub id: trap::TrapId<MacroTypeRepr>,
-    pub macro_call: Option<trap::Label<MacroCall>>,
-}
-
-impl trap::TrapEntry for MacroTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_type_reprs", vec![id.into()]);
-        if let Some(v) = self.macro_call {
-            out.add_tuple("macro_type_repr_macro_calls", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroTypeRepr {
-    fn class_name() -> &'static str { "MacroTypeRepr" }
-}
-
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<MacroTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MatchExpr {
-    pub id: trap::TrapId<MatchExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub scrutinee: Option<trap::Label<Expr>>,
-    pub match_arm_list: Option<trap::Label<MatchArmList>>,
-}
-
-impl trap::TrapEntry for MatchExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("match_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("match_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.scrutinee {
-            out.add_tuple("match_expr_scrutinees", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.match_arm_list {
-            out.add_tuple("match_expr_match_arm_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MatchExpr {
-    fn class_name() -> &'static str { "MatchExpr" }
-}
-
-impl From<trap::Label<MatchExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MatchExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<MatchExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<MatchExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MatchExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MatchExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct NeverTypeRepr {
-    pub id: trap::TrapId<NeverTypeRepr>,
-}
-
-impl trap::TrapEntry for NeverTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("never_type_reprs", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for NeverTypeRepr {
-    fn class_name() -> &'static str { "NeverTypeRepr" }
-}
-
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<NeverTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct OffsetOfExpr {
-    pub id: trap::TrapId<OffsetOfExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub fields: Vec<trap::Label<NameRef>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for OffsetOfExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("offset_of_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("offset_of_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("offset_of_expr_fields", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("offset_of_expr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for OffsetOfExpr {
-    fn class_name() -> &'static str { "OffsetOfExpr" }
-}
-
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<OffsetOfExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct OrPat {
-    pub id: trap::TrapId<OrPat>,
-    pub pats: Vec<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for OrPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("or_pats", vec![id.into()]);
-        for (i, v) in self.pats.into_iter().enumerate() {
-            out.add_tuple("or_pat_pats", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for OrPat {
-    fn class_name() -> &'static str { "OrPat" }
-}
-
-impl From<trap::Label<OrPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<OrPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OrPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<OrPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OrPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<OrPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<OrPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<OrPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Param {
-    pub id: trap::TrapId<Param>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for Param {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("params", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("param_base_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("param_base_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("param_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Param {
-    fn class_name() -> &'static str { "Param" }
-}
-
-impl From<trap::Label<Param>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Param>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Param is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Param>> for trap::Label<Element> {
-    fn from(value: trap::Label<Param>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Param is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Param>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Param>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Param is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Param>> for trap::Label<ParamBase> {
-    fn from(value: trap::Label<Param>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Param is a subclass of ParamBase
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ParenExpr {
-    pub id: trap::TrapId<ParenExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for ParenExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("paren_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("paren_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("paren_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ParenExpr {
-    fn class_name() -> &'static str { "ParenExpr" }
-}
-
-impl From<trap::Label<ParenExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ParenExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ParenExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ParenExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ParenExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ParenPat {
-    pub id: trap::TrapId<ParenPat>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for ParenPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("paren_pats", vec![id.into()]);
-        if let Some(v) = self.pat {
-            out.add_tuple("paren_pat_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ParenPat {
-    fn class_name() -> &'static str { "ParenPat" }
-}
-
-impl From<trap::Label<ParenPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ParenPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<ParenPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ParenPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<ParenPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ParenTypeRepr {
-    pub id: trap::TrapId<ParenTypeRepr>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for ParenTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("paren_type_reprs", vec![id.into()]);
-        if let Some(v) = self.type_repr {
-            out.add_tuple("paren_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ParenTypeRepr {
-    fn class_name() -> &'static str { "ParenTypeRepr" }
-}
-
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<ParenTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathAstNode {
-    _unused: ()
-}
-
-impl trap::TrapClass for PathAstNode {
-    fn class_name() -> &'static str { "PathAstNode" }
-}
-
-impl From<trap::Label<PathAstNode>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathAstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathAstNode>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathAstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathAstNode>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathAstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathAstNode>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<PathAstNode>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathExprBase {
-    _unused: ()
-}
-
-impl trap::TrapClass for PathExprBase {
-    fn class_name() -> &'static str { "PathExprBase" }
-}
-
-impl From<trap::Label<PathExprBase>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExprBase>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExprBase>> for trap::Label<Expr> {
-    fn from(value: trap::Label<PathExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExprBase>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathExprBase>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathTypeRepr {
-    pub id: trap::TrapId<PathTypeRepr>,
-    pub path: Option<trap::Label<Path>>,
-}
-
-impl trap::TrapEntry for PathTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("path_type_reprs", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_type_repr_paths", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PathTypeRepr {
-    fn class_name() -> &'static str { "PathTypeRepr" }
-}
-
-impl From<trap::Label<PathTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<PathTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PrefixExpr {
-    pub id: trap::TrapId<PrefixExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub operator_name: Option<String>,
-}
-
-impl trap::TrapEntry for PrefixExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("prefix_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("prefix_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("prefix_expr_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.operator_name {
-            out.add_tuple("prefix_expr_operator_names", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PrefixExpr {
-    fn class_name() -> &'static str { "PrefixExpr" }
-}
-
-impl From<trap::Label<PrefixExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PrefixExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PrefixExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<PrefixExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PrefixExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<PrefixExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PrefixExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PrefixExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PtrTypeRepr {
-    pub id: trap::TrapId<PtrTypeRepr>,
-    pub is_const: bool,
-    pub is_mut: bool,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for PtrTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ptr_type_reprs", vec![id.into()]);
-        if self.is_const {
-            out.add_tuple("ptr_type_repr_is_const", vec![id.into()]);
-        }
-        if self.is_mut {
-            out.add_tuple("ptr_type_repr_is_mut", vec![id.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("ptr_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PtrTypeRepr {
-    fn class_name() -> &'static str { "PtrTypeRepr" }
-}
-
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<PtrTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RangeExpr {
-    pub id: trap::TrapId<RangeExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub end: Option<trap::Label<Expr>>,
-    pub operator_name: Option<String>,
-    pub start: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for RangeExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("range_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("range_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.end {
-            out.add_tuple("range_expr_ends", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.operator_name {
-            out.add_tuple("range_expr_operator_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.start {
-            out.add_tuple("range_expr_starts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RangeExpr {
-    fn class_name() -> &'static str { "RangeExpr" }
-}
-
-impl From<trap::Label<RangeExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RangeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangeExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<RangeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangeExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<RangeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangeExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RangeExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RangePat {
-    pub id: trap::TrapId<RangePat>,
-    pub end: Option<trap::Label<Pat>>,
-    pub operator_name: Option<String>,
-    pub start: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for RangePat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("range_pats", vec![id.into()]);
-        if let Some(v) = self.end {
-            out.add_tuple("range_pat_ends", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.operator_name {
-            out.add_tuple("range_pat_operator_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.start {
-            out.add_tuple("range_pat_starts", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RangePat {
-    fn class_name() -> &'static str { "RangePat" }
-}
-
-impl From<trap::Label<RangePat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RangePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangePat>> for trap::Label<Element> {
-    fn from(value: trap::Label<RangePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangePat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RangePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RangePat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<RangePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordFieldList {
-    pub id: trap::TrapId<RecordFieldList>,
-    pub fields: Vec<trap::Label<RecordField>>,
-}
-
-impl trap::TrapEntry for RecordFieldList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_field_lists", vec![id.into()]);
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("record_field_list_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordFieldList {
-    fn class_name() -> &'static str { "RecordFieldList" }
-}
-
-impl From<trap::Label<RecordFieldList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordFieldList>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordFieldList>> for trap::Label<FieldList> {
-    fn from(value: trap::Label<RecordFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of FieldList
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordFieldList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RefExpr {
-    pub id: trap::TrapId<RefExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub is_const: bool,
-    pub is_mut: bool,
-    pub is_raw: bool,
-}
-
-impl trap::TrapEntry for RefExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ref_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("ref_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("ref_expr_exprs", vec![id.into(), v.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("ref_expr_is_const", vec![id.into()]);
-        }
-        if self.is_mut {
-            out.add_tuple("ref_expr_is_mut", vec![id.into()]);
-        }
-        if self.is_raw {
-            out.add_tuple("ref_expr_is_raw", vec![id.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RefExpr {
-    fn class_name() -> &'static str { "RefExpr" }
-}
-
-impl From<trap::Label<RefExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RefExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<RefExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<RefExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RefExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RefPat {
-    pub id: trap::TrapId<RefPat>,
-    pub is_mut: bool,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for RefPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ref_pats", vec![id.into()]);
-        if self.is_mut {
-            out.add_tuple("ref_pat_is_mut", vec![id.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("ref_pat_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RefPat {
-    fn class_name() -> &'static str { "RefPat" }
-}
-
-impl From<trap::Label<RefPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RefPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<RefPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RefPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<RefPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RefTypeRepr {
-    pub id: trap::TrapId<RefTypeRepr>,
-    pub is_mut: bool,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for RefTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("ref_type_reprs", vec![id.into()]);
-        if self.is_mut {
-            out.add_tuple("ref_type_repr_is_mut", vec![id.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("ref_type_repr_lifetimes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("ref_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RefTypeRepr {
-    fn class_name() -> &'static str { "RefTypeRepr" }
-}
-
-impl From<trap::Label<RefTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RefTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<RefTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RefTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RefTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<RefTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RestPat {
-    pub id: trap::TrapId<RestPat>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for RestPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("rest_pats", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("rest_pat_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RestPat {
-    fn class_name() -> &'static str { "RestPat" }
-}
-
-impl From<trap::Label<RestPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RestPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RestPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<RestPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RestPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RestPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RestPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<RestPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ReturnExpr {
-    pub id: trap::TrapId<ReturnExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for ReturnExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("return_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("return_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("return_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ReturnExpr {
-    fn class_name() -> &'static str { "ReturnExpr" }
-}
-
-impl From<trap::Label<ReturnExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ReturnExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ReturnExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ReturnExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ReturnExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ReturnExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ReturnExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ReturnExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SelfParam {
-    pub id: trap::TrapId<SelfParam>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub is_mut: bool,
-    pub lifetime: Option<trap::Label<Lifetime>>,
-    pub name: Option<trap::Label<Name>>,
-}
-
-impl trap::TrapEntry for SelfParam {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("self_params", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("param_base_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("param_base_type_reprs", vec![id.into(), v.into()]);
-        }
-        if self.is_mut {
-            out.add_tuple("self_param_is_mut", vec![id.into()]);
-        }
-        if let Some(v) = self.lifetime {
-            out.add_tuple("self_param_lifetimes", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("self_param_names", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for SelfParam {
-    fn class_name() -> &'static str { "SelfParam" }
-}
-
-impl From<trap::Label<SelfParam>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<SelfParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SelfParam>> for trap::Label<Element> {
-    fn from(value: trap::Label<SelfParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SelfParam>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<SelfParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SelfParam>> for trap::Label<ParamBase> {
-    fn from(value: trap::Label<SelfParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of ParamBase
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SlicePat {
-    pub id: trap::TrapId<SlicePat>,
-    pub pats: Vec<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for SlicePat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("slice_pats", vec![id.into()]);
-        for (i, v) in self.pats.into_iter().enumerate() {
-            out.add_tuple("slice_pat_pats", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for SlicePat {
-    fn class_name() -> &'static str { "SlicePat" }
-}
-
-impl From<trap::Label<SlicePat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<SlicePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SlicePat>> for trap::Label<Element> {
-    fn from(value: trap::Label<SlicePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SlicePat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<SlicePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SlicePat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<SlicePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SliceTypeRepr {
-    pub id: trap::TrapId<SliceTypeRepr>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for SliceTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("slice_type_reprs", vec![id.into()]);
-        if let Some(v) = self.type_repr {
-            out.add_tuple("slice_type_repr_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for SliceTypeRepr {
-    fn class_name() -> &'static str { "SliceTypeRepr" }
-}
-
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<SliceTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TryExpr {
-    pub id: trap::TrapId<TryExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for TryExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("try_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("try_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("try_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TryExpr {
-    fn class_name() -> &'static str { "TryExpr" }
-}
-
-impl From<trap::Label<TryExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TryExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<TryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TryExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<TryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TryExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TryExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TupleExpr {
-    pub id: trap::TrapId<TupleExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub fields: Vec<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for TupleExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("tuple_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("tuple_expr_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TupleExpr {
-    fn class_name() -> &'static str { "TupleExpr" }
-}
-
-impl From<trap::Label<TupleExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TupleExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<TupleExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<TupleExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TupleExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TupleFieldList {
-    pub id: trap::TrapId<TupleFieldList>,
-    pub fields: Vec<trap::Label<TupleField>>,
-}
-
-impl trap::TrapEntry for TupleFieldList {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_field_lists", vec![id.into()]);
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("tuple_field_list_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TupleFieldList {
-    fn class_name() -> &'static str { "TupleFieldList" }
-}
-
-impl From<trap::Label<TupleFieldList>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TupleFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleFieldList>> for trap::Label<Element> {
-    fn from(value: trap::Label<TupleFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleFieldList>> for trap::Label<FieldList> {
-    fn from(value: trap::Label<TupleFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of FieldList
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleFieldList>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TupleFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TuplePat {
-    pub id: trap::TrapId<TuplePat>,
-    pub fields: Vec<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for TuplePat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_pats", vec![id.into()]);
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("tuple_pat_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TuplePat {
-    fn class_name() -> &'static str { "TuplePat" }
-}
-
-impl From<trap::Label<TuplePat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TuplePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TuplePat>> for trap::Label<Element> {
-    fn from(value: trap::Label<TuplePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TuplePat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TuplePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TuplePat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<TuplePat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TupleTypeRepr {
-    pub id: trap::TrapId<TupleTypeRepr>,
-    pub fields: Vec<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for TupleTypeRepr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_type_reprs", vec![id.into()]);
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("tuple_type_repr_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TupleTypeRepr {
-    fn class_name() -> &'static str { "TupleTypeRepr" }
-}
-
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<Element> {
-    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<TypeRepr> {
-    fn from(value: trap::Label<TupleTypeRepr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of TypeRepr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeArg {
-    pub id: trap::TrapId<TypeArg>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-}
-
-impl trap::TrapEntry for TypeArg {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("type_args", vec![id.into()]);
-        if let Some(v) = self.type_repr {
-            out.add_tuple("type_arg_type_reprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TypeArg {
-    fn class_name() -> &'static str { "TypeArg" }
-}
-
-impl From<trap::Label<TypeArg>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeArg>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeArg>> for trap::Label<GenericArg> {
-    fn from(value: trap::Label<TypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of GenericArg
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeArg>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeParam {
-    pub id: trap::TrapId<TypeParam>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub default_type: Option<trap::Label<TypeRepr>>,
-    pub name: Option<trap::Label<Name>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-}
-
-impl trap::TrapEntry for TypeParam {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("type_params", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("type_param_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.default_type {
-            out.add_tuple("type_param_default_types", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("type_param_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("type_param_type_bound_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TypeParam {
-    fn class_name() -> &'static str { "TypeParam" }
-}
-
-impl From<trap::Label<TypeParam>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeParam>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeParam>> for trap::Label<GenericParam> {
-    fn from(value: trap::Label<TypeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of GenericParam
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeParam>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeParam>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct UnderscoreExpr {
-    pub id: trap::TrapId<UnderscoreExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for UnderscoreExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("underscore_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("underscore_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for UnderscoreExpr {
-    fn class_name() -> &'static str { "UnderscoreExpr" }
-}
-
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<UnderscoreExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Variant {
-    pub id: trap::TrapId<Variant>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-    pub field_list: Option<trap::Label<FieldList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for Variant {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("variants", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("variant_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("variant_exprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.field_list {
-            out.add_tuple("variant_field_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("variant_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("variant_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Variant {
-    fn class_name() -> &'static str { "Variant" }
-}
-
-impl From<trap::Label<Variant>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Variant>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Variant>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Variant>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Variant is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Variant>> for trap::Label<Element> {
-    fn from(value: trap::Label<Variant>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Variant>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Variant>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct WildcardPat {
-    pub id: trap::TrapId<WildcardPat>,
-}
-
-impl trap::TrapEntry for WildcardPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("wildcard_pats", vec![id.into()]);
-    }
-}
-
-impl trap::TrapClass for WildcardPat {
-    fn class_name() -> &'static str { "WildcardPat" }
-}
-
-impl From<trap::Label<WildcardPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<WildcardPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WildcardPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<WildcardPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WildcardPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<WildcardPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WildcardPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<WildcardPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct YeetExpr {
-    pub id: trap::TrapId<YeetExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for YeetExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("yeet_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("yeet_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("yeet_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for YeetExpr {
-    fn class_name() -> &'static str { "YeetExpr" }
-}
-
-impl From<trap::Label<YeetExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<YeetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YeetExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<YeetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YeetExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<YeetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YeetExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<YeetExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct YieldExpr {
-    pub id: trap::TrapId<YieldExpr>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub expr: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for YieldExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("yield_exprs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("yield_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.expr {
-            out.add_tuple("yield_expr_exprs", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for YieldExpr {
-    fn class_name() -> &'static str { "YieldExpr" }
-}
-
-impl From<trap::Label<YieldExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<YieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YieldExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<YieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YieldExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<YieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<YieldExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<YieldExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct BlockExpr {
-    pub id: trap::TrapId<BlockExpr>,
-    pub label: Option<trap::Label<Label>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub is_async: bool,
-    pub is_const: bool,
-    pub is_gen: bool,
-    pub is_move: bool,
-    pub is_try: bool,
-    pub is_unsafe: bool,
-    pub stmt_list: Option<trap::Label<StmtList>>,
-}
-
-impl trap::TrapEntry for BlockExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("block_exprs", vec![id.into()]);
-        if let Some(v) = self.label {
-            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("block_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if self.is_async {
-            out.add_tuple("block_expr_is_async", vec![id.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("block_expr_is_const", vec![id.into()]);
-        }
-        if self.is_gen {
-            out.add_tuple("block_expr_is_gen", vec![id.into()]);
-        }
-        if self.is_move {
-            out.add_tuple("block_expr_is_move", vec![id.into()]);
-        }
-        if self.is_try {
-            out.add_tuple("block_expr_is_try", vec![id.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("block_expr_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.stmt_list {
-            out.add_tuple("block_expr_stmt_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for BlockExpr {
-    fn class_name() -> &'static str { "BlockExpr" }
-}
-
-impl From<trap::Label<BlockExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BlockExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BlockExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BlockExpr>> for trap::Label<LabelableExpr> {
-    fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of LabelableExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<BlockExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct CallExpr {
-    pub id: trap::TrapId<CallExpr>,
-    pub arg_list: Option<trap::Label<ArgList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub function: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for CallExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("call_exprs", vec![id.into()]);
-        if let Some(v) = self.arg_list {
-            out.add_tuple("call_expr_base_arg_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("call_expr_base_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.function {
-            out.add_tuple("call_expr_functions", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for CallExpr {
-    fn class_name() -> &'static str { "CallExpr" }
-}
-
-impl From<trap::Label<CallExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<CallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExpr>> for trap::Label<CallExprBase> {
-    fn from(value: trap::Label<CallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of CallExprBase
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<CallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<CallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<CallExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<CallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Const {
-    pub id: trap::TrapId<Const>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub body: Option<trap::Label<Expr>>,
-    pub is_const: bool,
-    pub is_default: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for Const {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("consts", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("const_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.body {
-            out.add_tuple("const_bodies", vec![id.into(), v.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("const_is_const", vec![id.into()]);
-        }
-        if self.is_default {
-            out.add_tuple("const_is_default", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("const_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("const_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("const_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Const {
-    fn class_name() -> &'static str { "Const" }
-}
-
-impl From<trap::Label<Const>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<AssocItem> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of AssocItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<Element> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<Item> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Const>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Enum {
-    pub id: trap::TrapId<Enum>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub variant_list: Option<trap::Label<VariantList>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Enum {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("enums", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("enum_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("enum_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("enum_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.variant_list {
-            out.add_tuple("enum_variant_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("enum_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("enum_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Enum {
-    fn class_name() -> &'static str { "Enum" }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<Element> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<Item> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Enum>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ExternBlock {
-    pub id: trap::TrapId<ExternBlock>,
-    pub abi: Option<trap::Label<Abi>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub extern_item_list: Option<trap::Label<ExternItemList>>,
-    pub is_unsafe: bool,
-}
-
-impl trap::TrapEntry for ExternBlock {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("extern_blocks", vec![id.into()]);
-        if let Some(v) = self.abi {
-            out.add_tuple("extern_block_abis", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("extern_block_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.extern_item_list {
-            out.add_tuple("extern_block_extern_item_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("extern_block_is_unsafe", vec![id.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ExternBlock {
-    fn class_name() -> &'static str { "ExternBlock" }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<Item> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternBlock>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ExternCrate {
-    pub id: trap::TrapId<ExternCrate>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-    pub rename: Option<trap::Label<Rename>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for ExternCrate {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("extern_crates", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("extern_crate_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("extern_crate_name_refs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.rename {
-            out.add_tuple("extern_crate_renames", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("extern_crate_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ExternCrate {
-    fn class_name() -> &'static str { "ExternCrate" }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<Element> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<Item> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ExternCrate>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Function {
-    pub id: trap::TrapId<Function>,
-    pub param_list: Option<trap::Label<ParamList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub abi: Option<trap::Label<Abi>>,
-    pub body: Option<trap::Label<BlockExpr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub is_async: bool,
-    pub is_const: bool,
-    pub is_default: bool,
-    pub is_gen: bool,
-    pub is_unsafe: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub ret_type: Option<trap::Label<RetTypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Function {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("functions", vec![id.into()]);
-        if let Some(v) = self.param_list {
-            out.add_tuple("callable_param_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("callable_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.abi {
-            out.add_tuple("function_abis", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.body {
-            out.add_tuple("function_bodies", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("function_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_async {
-            out.add_tuple("function_is_async", vec![id.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("function_is_const", vec![id.into()]);
-        }
-        if self.is_default {
-            out.add_tuple("function_is_default", vec![id.into()]);
-        }
-        if self.is_gen {
-            out.add_tuple("function_is_gen", vec![id.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("function_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("function_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.ret_type {
-            out.add_tuple("function_ret_types", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("function_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("function_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Function {
-    fn class_name() -> &'static str { "Function" }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<AssocItem> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of AssocItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Callable> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Callable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Element> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<ExternItem> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of ExternItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Item> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Function>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Function>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Function is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Impl {
-    pub id: trap::TrapId<Impl>,
-    pub assoc_item_list: Option<trap::Label<AssocItemList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub is_const: bool,
-    pub is_default: bool,
-    pub is_unsafe: bool,
-    pub self_ty: Option<trap::Label<TypeRepr>>,
-    pub trait_: Option<trap::Label<TypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Impl {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("impls", vec![id.into()]);
-        if let Some(v) = self.assoc_item_list {
-            out.add_tuple("impl_assoc_item_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("impl_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("impl_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_const {
-            out.add_tuple("impl_is_const", vec![id.into()]);
-        }
-        if self.is_default {
-            out.add_tuple("impl_is_default", vec![id.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("impl_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.self_ty {
-            out.add_tuple("impl_self_ties", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.trait_ {
-            out.add_tuple("impl_traits", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("impl_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("impl_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Impl {
-    fn class_name() -> &'static str { "Impl" }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<Element> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<Item> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Impl>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Impl>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LoopingExpr {
-    _unused: ()
-}
-
-impl trap::TrapClass for LoopingExpr {
-    fn class_name() -> &'static str { "LoopingExpr" }
-}
-
-impl From<trap::Label<LoopingExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopingExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopingExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopingExpr>> for trap::Label<LabelableExpr> {
-    fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of LabelableExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopingExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroCall {
-    pub id: trap::TrapId<MacroCall>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub path: Option<trap::Label<Path>>,
-    pub token_tree: Option<trap::Label<TokenTree>>,
-}
-
-impl trap::TrapEntry for MacroCall {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_calls", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("macro_call_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.path {
-            out.add_tuple("macro_call_paths", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.token_tree {
-            out.add_tuple("macro_call_token_trees", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl MacroCall {
-    pub fn emit_expanded(id: trap::Label<Self>, value: trap::Label<AstNode>, out: &mut trap::Writer) {
-        out.add_tuple("macro_call_expandeds", vec![id.into(), value.into()]);
-    }
-}
-
-impl trap::TrapClass for MacroCall {
-    fn class_name() -> &'static str { "MacroCall" }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<AssocItem> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AssocItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<ExternItem> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of ExternItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<Item> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroCall>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroDef {
-    pub id: trap::TrapId<MacroDef>,
-    pub args: Option<trap::Label<TokenTree>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub body: Option<trap::Label<TokenTree>>,
-    pub name: Option<trap::Label<Name>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for MacroDef {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_defs", vec![id.into()]);
-        if let Some(v) = self.args {
-            out.add_tuple("macro_def_args", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("macro_def_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.body {
-            out.add_tuple("macro_def_bodies", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("macro_def_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("macro_def_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroDef {
-    fn class_name() -> &'static str { "MacroDef" }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<Item> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroDef>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MacroRules {
-    pub id: trap::TrapId<MacroRules>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub name: Option<trap::Label<Name>>,
-    pub token_tree: Option<trap::Label<TokenTree>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for MacroRules {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("macro_rules", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("macro_rules_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("macro_rules_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.token_tree {
-            out.add_tuple("macro_rules_token_trees", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("macro_rules_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MacroRules {
-    fn class_name() -> &'static str { "MacroRules" }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<Element> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<Item> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MacroRules>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct MethodCallExpr {
-    pub id: trap::TrapId<MethodCallExpr>,
-    pub arg_list: Option<trap::Label<ArgList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_arg_list: Option<trap::Label<GenericArgList>>,
-    pub name_ref: Option<trap::Label<NameRef>>,
-    pub receiver: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for MethodCallExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("method_call_exprs", vec![id.into()]);
-        if let Some(v) = self.arg_list {
-            out.add_tuple("call_expr_base_arg_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("call_expr_base_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_arg_list {
-            out.add_tuple("method_call_expr_generic_arg_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name_ref {
-            out.add_tuple("method_call_expr_name_refs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.receiver {
-            out.add_tuple("method_call_expr_receivers", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for MethodCallExpr {
-    fn class_name() -> &'static str { "MethodCallExpr" }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<CallExprBase> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of CallExprBase
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<MethodCallExpr>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<MethodCallExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Module {
-    pub id: trap::TrapId<Module>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub item_list: Option<trap::Label<ItemList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for Module {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("modules", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("module_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.item_list {
-            out.add_tuple("module_item_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("module_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("module_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Module {
-    fn class_name() -> &'static str { "Module" }
-}
-
-impl From<trap::Label<Module>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Module>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Module>> for trap::Label<Element> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Module>> for trap::Label<Item> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Module>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Module>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathExpr {
-    pub id: trap::TrapId<PathExpr>,
-    pub path: Option<trap::Label<Path>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for PathExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("path_exprs", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("path_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PathExpr {
-    fn class_name() -> &'static str { "PathExpr" }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<PathAstNode> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathAstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<PathExprBase> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathExprBase
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathExpr>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PathPat {
-    pub id: trap::TrapId<PathPat>,
-    pub path: Option<trap::Label<Path>>,
-}
-
-impl trap::TrapEntry for PathPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("path_pats", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for PathPat {
-    fn class_name() -> &'static str { "PathPat" }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<PathAstNode> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of PathAstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<PathPat>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<PathPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordExpr {
-    pub id: trap::TrapId<RecordExpr>,
-    pub path: Option<trap::Label<Path>>,
-    pub record_expr_field_list: Option<trap::Label<RecordExprFieldList>>,
-}
-
-impl trap::TrapEntry for RecordExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_exprs", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.record_expr_field_list {
-            out.add_tuple("record_expr_record_expr_field_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordExpr {
-    fn class_name() -> &'static str { "RecordExpr" }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<PathAstNode> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of PathAstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordExpr>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<RecordExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordExpr is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct RecordPat {
-    pub id: trap::TrapId<RecordPat>,
-    pub path: Option<trap::Label<Path>>,
-    pub record_pat_field_list: Option<trap::Label<RecordPatFieldList>>,
-}
-
-impl trap::TrapEntry for RecordPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("record_pats", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.record_pat_field_list {
-            out.add_tuple("record_pat_record_pat_field_lists", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for RecordPat {
-    fn class_name() -> &'static str { "RecordPat" }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<PathAstNode> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of PathAstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<RecordPat>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<RecordPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme RecordPat is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Static {
-    pub id: trap::TrapId<Static>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub body: Option<trap::Label<Expr>>,
-    pub is_mut: bool,
-    pub is_static: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for Static {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("statics", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("static_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.body {
-            out.add_tuple("static_bodies", vec![id.into(), v.into()]);
-        }
-        if self.is_mut {
-            out.add_tuple("static_is_mut", vec![id.into()]);
-        }
-        if self.is_static {
-            out.add_tuple("static_is_static", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("static_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("static_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("static_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Static {
-    fn class_name() -> &'static str { "Static" }
-}
-
-impl From<trap::Label<Static>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<Element> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<ExternItem> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of ExternItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<Item> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Static>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Static>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Static is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Struct {
-    pub id: trap::TrapId<Struct>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub field_list: Option<trap::Label<FieldList>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Struct {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("structs", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("struct_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.field_list {
-            out.add_tuple("struct_field_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("struct_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("struct_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("struct_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("struct_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Struct {
-    fn class_name() -> &'static str { "Struct" }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<Element> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<Item> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Struct>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Trait {
-    pub id: trap::TrapId<Trait>,
-    pub assoc_item_list: Option<trap::Label<AssocItemList>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub is_auto: bool,
-    pub is_unsafe: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Trait {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("traits", vec![id.into()]);
-        if let Some(v) = self.assoc_item_list {
-            out.add_tuple("trait_assoc_item_lists", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("trait_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("trait_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_auto {
-            out.add_tuple("trait_is_auto", vec![id.into()]);
-        }
-        if self.is_unsafe {
-            out.add_tuple("trait_is_unsafe", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("trait_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("trait_type_bound_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("trait_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("trait_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Trait {
-    fn class_name() -> &'static str { "Trait" }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<Element> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<Item> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Trait>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TraitAlias {
-    pub id: trap::TrapId<TraitAlias>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for TraitAlias {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("trait_aliases", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("trait_alias_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("trait_alias_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("trait_alias_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("trait_alias_type_bound_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("trait_alias_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("trait_alias_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TraitAlias {
-    fn class_name() -> &'static str { "TraitAlias" }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<Element> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<Item> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TraitAlias>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TupleStructPat {
-    pub id: trap::TrapId<TupleStructPat>,
-    pub path: Option<trap::Label<Path>>,
-    pub fields: Vec<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for TupleStructPat {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("tuple_struct_pats", vec![id.into()]);
-        if let Some(v) = self.path {
-            out.add_tuple("path_ast_node_paths", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.fields.into_iter().enumerate() {
-            out.add_tuple("tuple_struct_pat_fields", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TupleStructPat {
-    fn class_name() -> &'static str { "TupleStructPat" }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<Element> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<Pat> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Pat
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<PathAstNode> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of PathAstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TupleStructPat>> for trap::Label<Resolvable> {
-    fn from(value: trap::Label<TupleStructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Resolvable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TypeAlias {
-    pub id: trap::TrapId<TypeAlias>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub is_default: bool,
-    pub name: Option<trap::Label<Name>>,
-    pub type_repr: Option<trap::Label<TypeRepr>>,
-    pub type_bound_list: Option<trap::Label<TypeBoundList>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for TypeAlias {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("type_aliases", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("type_alias_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("type_alias_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if self.is_default {
-            out.add_tuple("type_alias_is_default", vec![id.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("type_alias_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_repr {
-            out.add_tuple("type_alias_type_reprs", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.type_bound_list {
-            out.add_tuple("type_alias_type_bound_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("type_alias_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("type_alias_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for TypeAlias {
-    fn class_name() -> &'static str { "TypeAlias" }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<AssocItem> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AssocItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<Element> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<ExternItem> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of ExternItem
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<Item> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<TypeAlias>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Union {
-    pub id: trap::TrapId<Union>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub generic_param_list: Option<trap::Label<GenericParamList>>,
-    pub name: Option<trap::Label<Name>>,
-    pub record_field_list: Option<trap::Label<RecordFieldList>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-    pub where_clause: Option<trap::Label<WhereClause>>,
-}
-
-impl trap::TrapEntry for Union {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("unions", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("union_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.generic_param_list {
-            out.add_tuple("union_generic_param_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.name {
-            out.add_tuple("union_names", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.record_field_list {
-            out.add_tuple("union_record_field_lists", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("union_visibilities", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.where_clause {
-            out.add_tuple("union_where_clauses", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Union {
-    fn class_name() -> &'static str { "Union" }
-}
-
-impl From<trap::Label<Union>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Union>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Union>> for trap::Label<Element> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Union>> for trap::Label<Item> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Union>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Union>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Use {
-    pub id: trap::TrapId<Use>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub use_tree: Option<trap::Label<UseTree>>,
-    pub visibility: Option<trap::Label<Visibility>>,
-}
-
-impl trap::TrapEntry for Use {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("uses", vec![id.into()]);
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("use_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.use_tree {
-            out.add_tuple("use_use_trees", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.visibility {
-            out.add_tuple("use_visibilities", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for Use {
-    fn class_name() -> &'static str { "Use" }
-}
-
-impl From<trap::Label<Use>> for trap::Label<Addressable> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Addressable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Use>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Use>> for trap::Label<Element> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Use>> for trap::Label<Item> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Item
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Use>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<Use>> for trap::Label<Stmt> {
-    fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Stmt
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ForExpr {
-    pub id: trap::TrapId<ForExpr>,
-    pub label: Option<trap::Label<Label>>,
-    pub loop_body: Option<trap::Label<BlockExpr>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub iterable: Option<trap::Label<Expr>>,
-    pub pat: Option<trap::Label<Pat>>,
-}
-
-impl trap::TrapEntry for ForExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("for_exprs", vec![id.into()]);
-        if let Some(v) = self.label {
-            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.loop_body {
-            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("for_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.iterable {
-            out.add_tuple("for_expr_iterables", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.pat {
-            out.add_tuple("for_expr_pats", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for ForExpr {
-    fn class_name() -> &'static str { "ForExpr" }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<LabelableExpr> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LabelableExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<ForExpr>> for trap::Label<LoopingExpr> {
-    fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LoopingExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct LoopExpr {
-    pub id: trap::TrapId<LoopExpr>,
-    pub label: Option<trap::Label<Label>>,
-    pub loop_body: Option<trap::Label<BlockExpr>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-}
-
-impl trap::TrapEntry for LoopExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("loop_exprs", vec![id.into()]);
-        if let Some(v) = self.label {
-            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.loop_body {
-            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("loop_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for LoopExpr {
-    fn class_name() -> &'static str { "LoopExpr" }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<LabelableExpr> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LabelableExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<LoopExpr>> for trap::Label<LoopingExpr> {
-    fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LoopingExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct WhileExpr {
-    pub id: trap::TrapId<WhileExpr>,
-    pub label: Option<trap::Label<Label>>,
-    pub loop_body: Option<trap::Label<BlockExpr>>,
-    pub attrs: Vec<trap::Label<Attr>>,
-    pub condition: Option<trap::Label<Expr>>,
-}
-
-impl trap::TrapEntry for WhileExpr {
-    fn extract_id(&mut self) -> trap::TrapId<Self> {
-        std::mem::replace(&mut self.id, trap::TrapId::Star)
-    }
-
-    fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {
-        out.add_tuple("while_exprs", vec![id.into()]);
-        if let Some(v) = self.label {
-            out.add_tuple("labelable_expr_labels", vec![id.into(), v.into()]);
-        }
-        if let Some(v) = self.loop_body {
-            out.add_tuple("looping_expr_loop_bodies", vec![id.into(), v.into()]);
-        }
-        for (i, v) in self.attrs.into_iter().enumerate() {
-            out.add_tuple("while_expr_attrs", vec![id.into(), i.into(), v.into()]);
-        }
-        if let Some(v) = self.condition {
-            out.add_tuple("while_expr_conditions", vec![id.into(), v.into()]);
-        }
-    }
-}
-
-impl trap::TrapClass for WhileExpr {
-    fn class_name() -> &'static str { "WhileExpr" }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<Expr> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Expr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<LabelableExpr> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LabelableExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<Locatable> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Locatable
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<WhileExpr>> for trap::Label<LoopingExpr> {
-    fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LoopingExpr
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
diff --git a/rust/extractor/src/rust_analyzer.rs b/rust/extractor/src/rust_analyzer.rs
index a896211333dc..3614f8cc938a 100644
--- a/rust/extractor/src/rust_analyzer.rs
+++ b/rust/extractor/src/rust_analyzer.rs
@@ -34,6 +34,7 @@ pub enum RustAnalyzer<'a> {
 pub struct FileSemanticInformation<'a> {
     pub file_id: EditionedFileId,
     pub semantics: &'a Semantics<'a, RootDatabase>,
+    pub vfs: &'a Vfs,
 }
 
 pub struct ParseResult<'a> {
@@ -87,7 +88,11 @@ impl<'a> RustAnalyzer<'a> {
                             ast: source_file,
                             text: input,
                             errors,
-                            semantics_info: Ok(FileSemanticInformation { file_id, semantics }),
+                            semantics_info: Ok(FileSemanticInformation {
+                                file_id,
+                                semantics,
+                                vfs,
+                            }),
                         };
                     }
                     debug!(
diff --git a/rust/extractor/src/translate.rs b/rust/extractor/src/translate.rs
index 4e9cda3e2aa1..35e0712df0fe 100644
--- a/rust/extractor/src/translate.rs
+++ b/rust/extractor/src/translate.rs
@@ -1,5 +1,6 @@
 mod base;
 mod generated;
+mod label_cache;
 mod mappings;
 
 pub use base::Translator;
diff --git a/rust/extractor/src/translate/base.rs b/rust/extractor/src/translate/base.rs
index 84f8268d5046..65e58213f52e 100644
--- a/rust/extractor/src/translate/base.rs
+++ b/rust/extractor/src/translate/base.rs
@@ -1,29 +1,32 @@
-use super::mappings::{AddressableAst, AddressableHir, PathAst};
+use super::mappings::{ModuleItem, PathAst};
 use crate::generated::MacroCall;
 use crate::generated::{self};
 use crate::rust_analyzer::FileSemanticInformation;
+use crate::translate::label_cache::CanonicalPathLabelCache;
+use crate::trap::AsTrapKeyPart;
 use crate::trap::{DiagnosticSeverity, TrapFile, TrapId};
 use crate::trap::{Label, TrapClass};
-use itertools::Either;
-use log::Level;
-use ra_ap_base_db::salsa::InternKey;
+use crate::{cache_get_or_assign, trap_key};
+use itertools::{Either, Itertools};
+use log::{warn, Level};
 use ra_ap_base_db::CrateOrigin;
 use ra_ap_hir::db::ExpandDatabase;
 use ra_ap_hir::{
-    Adt, Crate, ItemContainer, Module, ModuleDef, PathResolution, Semantics, Type, Variant,
+    Adt, Crate, Function, HasContainer, ItemContainer, Module, ModuleDef, PathResolution,
+    Semantics, TraitRef, Type, Variant,
 };
-use ra_ap_hir_def::type_ref::Mutability;
 use ra_ap_hir_def::ModuleId;
 use ra_ap_hir_expand::ExpandTo;
 use ra_ap_ide_db::line_index::{LineCol, LineIndex};
 use ra_ap_ide_db::RootDatabase;
 use ra_ap_parser::SyntaxKind;
 use ra_ap_span::{EditionedFileId, TextSize};
-use ra_ap_syntax::ast::HasName;
 use ra_ap_syntax::{
     ast, AstNode, NodeOrToken, SyntaxElementChildren, SyntaxError, SyntaxNode, SyntaxToken,
     TextRange,
 };
+use ra_ap_vfs::Vfs;
+use std::path::PathBuf;
 
 #[macro_export]
 macro_rules! emit_detached {
@@ -31,25 +34,67 @@ macro_rules! emit_detached {
         $self.extract_macro_call_expanded(&$node, $label);
     };
     (Function, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_fn_def,
+            canonical_path_from_function
+        );
     };
     (Trait, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_trait_def,
+            canonical_path_from_module_item
+        );
     };
     (Struct, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_struct_def,
+            canonical_path_from_module_item
+        );
     };
     (Enum, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_enum_def,
+            canonical_path_from_module_item
+        );
     };
     (Union, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_union_def,
+            canonical_path_from_module_item
+        );
     };
     (Module, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin(&$node, $label.into());
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_module_def,
+            canonical_path_from_module
+        );
     };
     (Variant, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin_of_enum_variant(&$node, $label);
+        emit_canonical_origin!(
+            $self,
+            $node,
+            $label,
+            to_enum_variant_def,
+            canonical_path_from_enum_variant
+        );
     };
     // TODO canonical origin of other items
     (PathExpr, $self:ident, $node:ident, $label:ident) => {
@@ -73,6 +118,23 @@ macro_rules! emit_detached {
     ($($_:tt)*) => {};
 }
 
+#[macro_export]
+macro_rules! emit_canonical_origin {
+    ($self:ident, $node:ident, $label:ident, $to_def:ident, $canonical_path_method:ident) => {
+        (|| {
+            let sema = $self.semantics.as_ref()?;
+            let def = sema.$to_def(&$node)?;
+            let path = $self.$canonical_path_method(def)?;
+            generated::Addressable::emit_canonical_path(
+                $label.into(),
+                path.into(),
+                &mut $self.trap.writer,
+            );
+            Some(())
+        })();
+    };
+}
+
 pub struct Translator<'a> {
     pub trap: TrapFile,
     path: &'a str,
@@ -80,6 +142,8 @@ pub struct Translator<'a> {
     line_index: LineIndex,
     file_id: Option<EditionedFileId>,
     pub semantics: Option<&'a Semantics<'a, RootDatabase>>,
+    vfs: Option<&'a Vfs>,
+    canonical_path_cache: CanonicalPathLabelCache,
 }
 
 impl<'a> Translator<'a> {
@@ -97,6 +161,8 @@ impl<'a> Translator<'a> {
             line_index,
             file_id: semantic_info.map(|i| i.file_id),
             semantics: semantic_info.map(|i| i.semantics),
+            vfs: semantic_info.map(|i| i.vfs),
+            canonical_path_cache: CanonicalPathLabelCache::new(),
         }
     }
     fn location(&self, range: TextRange) -> (LineCol, LineCol) {
@@ -322,146 +388,327 @@ impl<'a> Translator<'a> {
             );
         }
     }
-    fn canonical_path_from_type(&self, ty: Type) -> Option<String> {
-        let sema = self.semantics.as_ref().unwrap();
-        // rust-analyzer doesn't provide a type enum directly
-        if let Some(it) = ty.as_adt() {
-            return match it {
-                Adt::Struct(it) => self.canonical_path_from_hir(it),
-                Adt::Union(it) => self.canonical_path_from_hir(it),
-                Adt::Enum(it) => self.canonical_path_from_hir(it),
-            };
-        };
-        if let Some((it, size)) = ty.as_array(sema.db) {
-            return self
-                .canonical_path_from_type(it)
-                .map(|p| format!("[{p}; {size}]"));
-        }
-        if let Some(it) = ty.as_slice() {
-            return self
-                .canonical_path_from_type(it)
-                .map(|p| format!("[{}]", p));
-        }
-        if let Some(it) = ty.as_builtin() {
-            return Some(it.name().as_str().to_owned());
-        }
-        if let Some(it) = ty.as_dyn_trait() {
-            return self.canonical_path_from_hir(it).map(|p| format!("dyn {p}"));
-        }
-        if let Some((it, mutability)) = ty.as_reference() {
-            let mut_str = match mutability {
-                Mutability::Shared => "",
-                Mutability::Mut => "mut ",
-            };
-            return self
-                .canonical_path_from_type(it)
-                .map(|p| format!("&{mut_str}{p}"));
-        }
-        if let Some(it) = ty.as_impl_traits(sema.db) {
-            let paths = it
-                .map(|t| self.canonical_path_from_hir(t))
-                .collect::<Option<Vec<_>>>()?;
-            return Some(format!("impl {}", paths.join(" + ")));
-        }
-        if ty.as_type_param(sema.db).is_some() {
-            // from the canonical path perspective, we just want a special name
-            // e.g. `crate::<_ as SomeTrait>::func`
-            return Some("_".to_owned());
-        }
-        None
-    }
 
-    fn canonical_path_from_hir_module(&self, item: Module) -> Option<String> {
-        if let Some(block_id) = ModuleId::from(item).containing_block() {
-            // this means this is a block module, i.e. a virtual module for a block scope
-            return Some(format!("{{{}}}", block_id.as_intern_id()));
-        }
-        if item.is_crate_root() {
-            return Some("crate".into());
-        }
-        self.canonical_path_from_hir::<ast::Module>(item)
+    fn emit_derived_type_canonical_path<T: AsRef<str>>(
+        &mut self,
+        modifiers: &[T],
+        bases: Vec<Label<generated::TypeCanonicalPath>>,
+    ) -> Label<generated::TypeCanonicalPath> {
+        let modifiers = modifiers
+            .iter()
+            .map(|s| s.as_ref().to_owned())
+            .collect::<Vec<String>>();
+        let id = itertools::interleave(
+            modifiers.iter().cloned(),
+            bases.iter().map(|t| t.as_key_part()),
+        )
+        .join("")
+        .into();
+        self.trap
+            .emit(generated::DerivedTypeCanonicalPath {
+                id,
+                modifiers,
+                base: bases,
+            })
+            .into()
     }
 
-    fn canonical_path_from_hir<T: AstNode>(&self, item: impl AddressableHir<T>) -> Option<String> {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        let name = item.name(sema)?;
-        let container = item.container(sema.db);
-        let prefix = match container {
-            ItemContainer::Trait(it) => self.canonical_path_from_hir(it),
-            ItemContainer::Impl(it) => {
-                let ty = self.canonical_path_from_type(it.self_ty(sema.db))?;
-                if let Some(trait_) = it.trait_(sema.db) {
-                    let tr = self.canonical_path_from_hir(trait_)?;
-                    Some(format!("<{ty} as {tr}>"))
+    fn canonical_path_from_type(
+        &mut self,
+        ty: Type,
+    ) -> Option<Label<generated::TypeCanonicalPath>> {
+        cache_get_or_assign!(self.canonical_path_cache, ty, {
+            let sema = self.semantics.as_ref().unwrap();
+            // rust-analyzer doesn't provide a type enum directly
+            if let Some(it) = ty.as_adt() {
+                let name = it.name(sema.db).as_str().to_owned();
+                let module = it.module(sema.db);
+                let mut generic_args = Vec::new();
+                for arg in ty.type_arguments() {
+                    let path = self.canonical_path_from_type(arg)?;
+                    generic_args.push(
+                        self.trap
+                            .emit(generated::TypeGenericTypeArg {
+                                id: trap_key!(path),
+                                path,
+                            })
+                            .into(),
+                    );
+                }
+                let namespace = self.canonical_path_from_module(module)?;
+                let base = self.trap.emit(generated::ModuleItemCanonicalPath {
+                    id: trap_key!(namespace, "::", name),
+                    namespace,
+                    name,
+                });
+                let path = self.trap.emit(generated::ParametrizedCanonicalPath {
+                    id: trap_key!(base, generic_args),
+                    base,
+                    generic_args,
+                });
+                Some(
+                    self.trap
+                        .emit(generated::ConcreteTypeCanonicalPath {
+                            id: trap_key!(path),
+                            path,
+                        })
+                        .into(),
+                )
+            } else if let Some((it, size)) = ty.as_array(sema.db) {
+                let modifiers = ["[".to_owned(), format!("; {size}]")];
+                let bases = vec![self.canonical_path_from_type(it)?];
+                Some(self.emit_derived_type_canonical_path(&modifiers, bases))
+            } else if let Some(it) = ty.as_slice() {
+                let modifiers = ["[", "]"];
+                let bases = vec![self.canonical_path_from_type(it)?];
+                Some(self.emit_derived_type_canonical_path(&modifiers, bases))
+            } else if ty.is_unit() {
+                let modifiers = ["()"];
+                let bases = vec![];
+                Some(self.emit_derived_type_canonical_path(&modifiers, bases))
+            } else if let Some(it) = ty.as_builtin() {
+                let name = it.name().as_str().to_owned();
+                Some(
+                    self.trap
+                        .emit(generated::BuiltinTypeCanonicalPath {
+                            id: trap_key!(name),
+                            name,
+                        })
+                        .into(),
+                )
+            } else if let Some((it, mutability)) = ty.as_reference() {
+                let modifiers = [format!("&{}", mutability.as_keyword_for_ref())];
+                let bases = vec![self.canonical_path_from_type(it)?];
+                Some(self.emit_derived_type_canonical_path(&modifiers, bases))
+            } else if ty.as_type_param(sema.db).is_some() {
+                // from the canonical path perspective, we just want a special name
+                // e.g. `crate::<_ as SomeTrait>::func`
+                // TODO: This will not work for assigning trap keys to types themselves!
+                Some(
+                    self.trap
+                        .emit(generated::PlaceholderTypeCanonicalPath { id: trap_key!("_") })
+                        .into(),
+                )
+            } else {
+                let tuple_args = ty.tuple_fields(sema.db);
+                if tuple_args.is_empty() {
+                    None
                 } else {
-                    Some(format!("<{ty}>"))
+                    let modifiers = std::iter::once("(")
+                        .chain(std::iter::repeat(", ").take(tuple_args.len() - 1))
+                        .chain(std::iter::once(")"))
+                        .collect::<Vec<_>>();
+                    let bases = tuple_args
+                        .into_iter()
+                        .map(|arg| self.canonical_path_from_type(arg))
+                        .collect::<Option<Vec<_>>>()?;
+                    Some(self.emit_derived_type_canonical_path(&modifiers, bases))
                 }
             }
-            ItemContainer::Module(it) => self.canonical_path_from_hir_module(it),
-            ItemContainer::ExternBlock() | ItemContainer::Crate(_) => Some("".to_owned()),
-        }?;
-        Some(format!("{prefix}::{name}"))
+        })
     }
 
-    fn canonical_path_from_module_def(&self, item: ModuleDef) -> Option<String> {
-        match item {
-            ModuleDef::Module(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Function(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Enum(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Struct(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Union(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Trait(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Variant(it) => self.canonical_path_from_enum_variant(it),
-            ModuleDef::Static(_) => None,
-            ModuleDef::TraitAlias(_) => None,
-            ModuleDef::TypeAlias(_) => None,
-            ModuleDef::BuiltinType(_) => None,
-            ModuleDef::Macro(_) => None,
-            ModuleDef::Const(_) => None,
-        }
+    fn emit_crate_root(&mut self, item: Crate) -> Option<Label<generated::CrateRef>> {
+        cache_get_or_assign!(self.canonical_path_cache, item, {
+            let db = self.semantics.unwrap().db;
+            let (repo, name) = match item.origin(db) {
+                CrateOrigin::Rustc { name } => (None, Some(name)),
+                CrateOrigin::Local { repo, name } => (repo, name),
+                CrateOrigin::Library { repo, name } => (repo, Some(name)),
+                CrateOrigin::Lang(it) => {
+                    let name = it.to_string();
+                    return Some(
+                        self.trap
+                            .emit(generated::LangCrateRef {
+                                id: trap_key!(name),
+                                name,
+                            })
+                            .into(),
+                    );
+                }
+            };
+            let name = name.map(|s| s.to_string());
+            let vfs_path = self.vfs.unwrap().file_path(item.root_file(db));
+            let Some(file) = vfs_path.as_path() else {
+                warn!("Crate root file not found: {}", vfs_path);
+                return None;
+            };
+            let source = self.trap.emit_file(&PathBuf::from(file.as_os_str()));
+            Some(
+                self.trap
+                    .emit(generated::RepoCrateRef {
+                        id: trap_key!(source, name, repo),
+                        name,
+                        repo,
+                        source,
+                    })
+                    .into(),
+            )
+        })
     }
 
-    fn canonical_path_from_enum_variant(&self, item: Variant) -> Option<String> {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        let prefix = self.canonical_path_from_hir(item.parent_enum(sema.db))?;
-        let name = item.name(sema.db);
-        Some(format!("{prefix}::{}", name.as_str()))
+    pub(crate) fn canonical_path_from_module(
+        &mut self,
+        item: Module,
+    ) -> Option<Label<generated::Namespace>> {
+        cache_get_or_assign!(self.canonical_path_cache, item, {
+            // if we have a Hir entity, it means we have semantics
+            let sema = self.semantics.as_ref().unwrap();
+            // do not assign namespaces to unnamed modules, i.e. a virtual modules for block scopes
+            if ModuleId::from(item).is_block_module() {
+                return None;
+            }
+            let path = item
+                .path_to_root(sema.db)
+                .iter()
+                .filter_map(|m| m.name(sema.db))
+                .map(|n| n.as_str().to_owned())
+                .join("::");
+            let root = self.emit_crate_root(item.krate())?;
+            Some(self.trap.emit(generated::Namespace {
+                id: trap_key!(root, "::", path),
+                root,
+                path,
+            }))
+        })
     }
 
-    fn origin_from_hir<T: AstNode>(&self, item: impl AddressableHir<T>) -> String {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        self.origin_from_crate(item.module(sema).krate())
+    pub(crate) fn canonical_path_from_module_item(
+        &mut self,
+        item: impl ModuleItem,
+    ) -> Option<Label<generated::ModuleItemCanonicalPath>> {
+        cache_get_or_assign!(self.canonical_path_cache, item, {
+            // if we have a Hir entity, it means we have semantics
+            let sema = self.semantics.as_ref().unwrap();
+            let module = item.module(sema);
+            let name = item.name(sema).as_str().to_owned();
+            let namespace = self.canonical_path_from_module(module)?;
+            Some(self.trap.emit(generated::ModuleItemCanonicalPath {
+                id: trap_key!(namespace, "::", name),
+                namespace,
+                name,
+            }))
+        })
+    }
+
+    fn canonical_path_from_trait_ref(
+        &mut self,
+        item: TraitRef,
+    ) -> Option<Label<generated::ParametrizedCanonicalPath>> {
+        cache_get_or_assign!(self.canonical_path_cache, item, {
+            let db = self.semantics.unwrap().db;
+            let trait_ = item.trait_();
+            let base = self.canonical_path_from_module_item(trait_)?;
+            let param_count = trait_.type_or_const_param_count(db, false);
+            let mut generic_args = Vec::new();
+            for i in 1..=param_count {
+                // TODO seems like you can't get const arguments currently...
+                let arg = item.get_type_argument(i)?;
+                let path = self.canonical_path_from_type(arg)?;
+                generic_args.push(
+                    self.trap
+                        .emit(generated::TypeGenericTypeArg {
+                            id: trap_key!(path),
+                            path,
+                        })
+                        .into(),
+                );
+            }
+            Some(self.trap.emit(generated::ParametrizedCanonicalPath {
+                id: trap_key!(base, generic_args),
+                base,
+                generic_args,
+            }))
+        })
     }
 
-    fn origin_from_crate(&self, item: Crate) -> String {
+    pub(crate) fn canonical_path_from_function(
+        &mut self,
+        item: Function,
+    ) -> Option<Label<generated::CanonicalPath>> {
         // if we have a Hir entity, it means we have semantics
         let sema = self.semantics.as_ref().unwrap();
-        match item.origin(sema.db) {
-            CrateOrigin::Rustc { name } => format!("rustc:{}", name),
-            CrateOrigin::Local { repo, name } => format!(
-                "repo:{}:{}",
-                repo.unwrap_or_default(),
-                name.map(|s| s.as_str().to_owned()).unwrap_or_default()
-            ),
-            CrateOrigin::Library { repo, name } => {
-                format!("repo:{}:{}", repo.unwrap_or_default(), name)
+        let name = item.name(sema.db).as_str().to_owned();
+        match item.container(sema.db) {
+            ItemContainer::Trait(it) => {
+                let parent = self.canonical_path_from_module_item(it)?;
+                Some(
+                    self.trap
+                        .emit(generated::TypeItemCanonicalPath {
+                            id: trap_key!(parent, "::", name),
+                            parent,
+                            name,
+                        })
+                        .into(),
+                )
+            }
+            ItemContainer::Impl(it) => {
+                let ty = it.self_ty(sema.db);
+                if let Some(trait_path) = it
+                    .trait_ref(sema.db)
+                    .and_then(|t| self.canonical_path_from_trait_ref(t))
+                {
+                    let type_path = self.canonical_path_from_type(ty)?;
+                    Some(
+                        self.trap
+                            .emit(generated::TraitImplItemCanonicalPath {
+                                id: trap_key!("<", type_path, "as", trait_path, ">::", name),
+                                type_path,
+                                trait_path,
+                                name,
+                            })
+                            .into(),
+                    )
+                } else {
+                    // with no trait this must be an Adt impl
+                    let adt = ty.as_adt()?;
+                    let parent = self.canonical_path_from_module_item(adt)?;
+                    Some(
+                        self.trap
+                            .emit(generated::TypeImplItemCanonicalPath {
+                                id: trap_key!(parent, name),
+                                parent,
+                                name,
+                            })
+                            .into(),
+                    )
+                }
+            }
+            ItemContainer::Module(it) => {
+                let namespace = self.canonical_path_from_module(it)?;
+                Some(
+                    self.trap
+                        .emit(generated::ModuleItemCanonicalPath {
+                            id: trap_key!(namespace, "::", name),
+                            namespace,
+                            name,
+                        })
+                        .into(),
+                )
             }
-            CrateOrigin::Lang(it) => format!("lang:{}", it),
+            ItemContainer::ExternBlock() => None,
+            ItemContainer::Crate(_) => None,
         }
     }
 
-    fn origin_from_module_def(&self, item: ModuleDef) -> Option<String> {
+    fn canonical_path_from_module_def(
+        &mut self,
+        item: ModuleDef,
+    ) -> Option<Label<generated::CanonicalPath>> {
         match item {
-            ModuleDef::Module(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Function(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Enum(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Struct(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Union(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Trait(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Variant(it) => Some(self.origin_from_enum_variant(it)),
+            ModuleDef::Module(it) => self.canonical_path_from_module(it).map(|l| l.into()),
+            ModuleDef::Function(it) => self.canonical_path_from_function(it),
+            ModuleDef::Adt(Adt::Enum(it)) => {
+                self.canonical_path_from_module_item(it).map(|l| l.into())
+            }
+            ModuleDef::Adt(Adt::Struct(it)) => {
+                self.canonical_path_from_module_item(it).map(|l| l.into())
+            }
+            ModuleDef::Adt(Adt::Union(it)) => {
+                self.canonical_path_from_module_item(it).map(|l| l.into())
+            }
+            ModuleDef::Trait(it) => self.canonical_path_from_module_item(it).map(|l| l.into()),
+            ModuleDef::Variant(it) => self.canonical_path_from_enum_variant(it),
             ModuleDef::Static(_) => None,
             ModuleDef::TraitAlias(_) => None,
             ModuleDef::TypeAlias(_) => None,
@@ -471,50 +718,26 @@ impl<'a> Translator<'a> {
         }
     }
 
-    fn origin_from_enum_variant(&self, item: Variant) -> String {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        self.origin_from_hir(item.parent_enum(sema.db))
-    }
-
-    pub(crate) fn extract_canonical_origin<T: AddressableAst + HasName>(
-        &mut self,
-        item: &T,
-        label: Label<generated::Addressable>,
-    ) {
-        (|| {
-            let sema = self.semantics.as_ref()?;
-            let def = T::Hir::try_from_source(item, sema)?;
-            let path = self.canonical_path_from_hir(def)?;
-            let origin = self.origin_from_hir(def);
-            generated::Addressable::emit_crate_origin(label, origin, &mut self.trap.writer);
-            generated::Addressable::emit_extended_canonical_path(
-                label,
-                path,
-                &mut self.trap.writer,
-            );
-            Some(())
-        })();
-    }
-
-    pub(crate) fn extract_canonical_origin_of_enum_variant(
+    pub(crate) fn canonical_path_from_enum_variant(
         &mut self,
-        item: &ast::Variant,
-        label: Label<generated::Variant>,
-    ) {
-        (|| {
-            let sema = self.semantics.as_ref()?;
-            let def = sema.to_enum_variant_def(item)?;
-            let path = self.canonical_path_from_enum_variant(def)?;
-            let origin = self.origin_from_enum_variant(def);
-            generated::Addressable::emit_crate_origin(label.into(), origin, &mut self.trap.writer);
-            generated::Addressable::emit_extended_canonical_path(
-                label.into(),
-                path,
-                &mut self.trap.writer,
-            );
-            Some(())
-        })();
+        item: Variant,
+    ) -> Option<Label<generated::CanonicalPath>> {
+        cache_get_or_assign!(self.canonical_path_cache, item, {
+            // if we have a Hir entity, it means we have semantics
+            let sema = self.semantics.as_ref().unwrap();
+            let enum_ = item.parent_enum(sema.db);
+            let name = item.name(sema.db).as_str().to_owned();
+            let parent = self.canonical_path_from_module_item(enum_)?;
+            Some(
+                self.trap
+                    .emit(generated::TypeItemCanonicalPath {
+                        id: trap_key!(parent, "::", name),
+                        parent,
+                        name,
+                    })
+                    .into(),
+            )
+        })
     }
 
     pub(crate) fn extract_path_canonical_destination(
@@ -529,10 +752,8 @@ impl<'a> Translator<'a> {
             let PathResolution::Def(def) = resolution else {
                 return None;
             };
-            let origin = self.origin_from_module_def(def)?;
             let path = self.canonical_path_from_module_def(def)?;
-            generated::Resolvable::emit_resolved_crate_origin(label, origin, &mut self.trap.writer);
-            generated::Resolvable::emit_resolved_path(label, path, &mut self.trap.writer);
+            generated::Resolvable::emit_resolved_canonical_path(label, path, &mut self.trap.writer);
             Some(())
         })();
     }
@@ -548,14 +769,12 @@ impl<'a> Translator<'a> {
             let Either::Left(function) = resolved else {
                 return None;
             };
-            let origin = self.origin_from_hir(function);
-            let path = self.canonical_path_from_hir(function)?;
-            generated::Resolvable::emit_resolved_crate_origin(
+            let path = self.canonical_path_from_function(function)?;
+            generated::Resolvable::emit_resolved_canonical_path(
                 label.into(),
-                origin,
+                path,
                 &mut self.trap.writer,
             );
-            generated::Resolvable::emit_resolved_path(label.into(), path, &mut self.trap.writer);
             Some(())
         })();
     }
diff --git a/rust/extractor/src/translate/generated.rs b/rust/extractor/src/translate/generated.rs
index a87f2d74caf4..93079a0f0fbd 100644
--- a/rust/extractor/src/translate/generated.rs
+++ b/rust/extractor/src/translate/generated.rs
@@ -4,7 +4,7 @@
 
 use super::base::Translator;
 use super::mappings::TextValue;
-use crate::emit_detached;
+use crate::{emit_detached,emit_canonical_origin};
 use crate::generated;
 use crate::trap::{Label, TrapId};
 use ra_ap_syntax::ast::{
diff --git a/rust/extractor/src/translate/label_cache.rs b/rust/extractor/src/translate/label_cache.rs
new file mode 100644
index 000000000000..9f41406a6211
--- /dev/null
+++ b/rust/extractor/src/translate/label_cache.rs
@@ -0,0 +1,163 @@
+use crate::generated::{self};
+use crate::trap::{Label, TrapClass, UntypedLabel};
+use ra_ap_hir::{
+    Adt, Crate, Enum, Function, Module, Struct, Trait, TraitRef, Type, Union, Variant,
+};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Key {
+    Type(Type),
+    Function(Function),
+    Trait(Trait),
+    Enum(Enum),
+    Union(Union),
+    Struct(Struct),
+    Crate(Crate),
+    Module(Module),
+    TraitRef(TraitRef),
+    Variant(Variant),
+}
+
+pub trait StorableAsCanonicalPath {
+    type TrapClass: TrapClass;
+
+    fn to_key(&self) -> Key;
+}
+
+pub trait StorableAsModuleItemCanonicalPath {
+    fn to_key(&self) -> Key;
+}
+
+impl<T: StorableAsModuleItemCanonicalPath> StorableAsCanonicalPath for T {
+    type TrapClass = generated::ModuleItemCanonicalPath;
+
+    fn to_key(&self) -> Key {
+        <Self as StorableAsModuleItemCanonicalPath>::to_key(self)
+    }
+}
+
+impl StorableAsCanonicalPath for Type {
+    type TrapClass = generated::TypeCanonicalPath;
+
+    fn to_key(&self) -> Key {
+        Key::Type(self.clone())
+    }
+}
+
+impl StorableAsCanonicalPath for Function {
+    type TrapClass = generated::CanonicalPath;
+
+    fn to_key(&self) -> Key {
+        Key::Function(*self)
+    }
+}
+
+impl StorableAsModuleItemCanonicalPath for Trait {
+    fn to_key(&self) -> Key {
+        Key::Trait(*self)
+    }
+}
+
+impl StorableAsModuleItemCanonicalPath for Adt {
+    fn to_key(&self) -> Key {
+        match *self {
+            Adt::Struct(it) => Key::Struct(it),
+            Adt::Union(it) => Key::Union(it),
+            Adt::Enum(it) => Key::Enum(it),
+        }
+    }
+}
+
+impl StorableAsModuleItemCanonicalPath for Enum {
+    fn to_key(&self) -> Key {
+        Key::Enum(*self)
+    }
+}
+
+impl StorableAsModuleItemCanonicalPath for Union {
+    fn to_key(&self) -> Key {
+        Key::Union(*self)
+    }
+}
+
+impl StorableAsModuleItemCanonicalPath for Struct {
+    fn to_key(&self) -> Key {
+        Key::Struct(*self)
+    }
+}
+
+impl StorableAsCanonicalPath for Crate {
+    type TrapClass = generated::CrateRef;
+
+    fn to_key(&self) -> Key {
+        Key::Crate(*self)
+    }
+}
+
+impl StorableAsCanonicalPath for Module {
+    type TrapClass = generated::Namespace;
+
+    fn to_key(&self) -> Key {
+        Key::Module(*self)
+    }
+}
+
+impl StorableAsCanonicalPath for TraitRef {
+    type TrapClass = generated::ParametrizedCanonicalPath;
+
+    fn to_key(&self) -> Key {
+        Key::TraitRef(self.clone())
+    }
+}
+
+impl StorableAsCanonicalPath for Variant {
+    type TrapClass = generated::CanonicalPath;
+
+    fn to_key(&self) -> Key {
+        Key::Variant(*self)
+    }
+}
+
+pub struct CanonicalPathLabelCache {
+    cache: HashMap<Key, Option<UntypedLabel>>,
+}
+
+impl CanonicalPathLabelCache {
+    pub fn new() -> Self {
+        Self {
+            cache: HashMap::new(),
+        }
+    }
+
+    pub fn get<T: StorableAsCanonicalPath>(&self, key: &T) -> Option<Option<Label<T::TrapClass>>> {
+        self.cache.get(&key.to_key()).map(|maybe| {
+            maybe.map(|l| {
+                // UNSAFE: The label can only have been inserted as Label<T::TrapClass>
+                unsafe { Label::from_untyped(l) }
+            })
+        })
+    }
+
+    pub fn insert<T: StorableAsCanonicalPath>(
+        &mut self,
+        key: &T,
+        label: Option<Label<T::TrapClass>>,
+    ) {
+        self.cache
+            .insert(key.to_key(), label.map(|l| l.as_untyped()));
+    }
+}
+
+#[macro_export]
+macro_rules! cache_get_or_assign {
+    ($cache:expr, $key:expr, $get:expr) => {{
+        if let Some(label) = $cache.get(&$key) {
+            label
+        } else {
+            let label = $get;
+            $cache.insert(&$key, label.clone());
+            label
+        }
+    }};
+}
diff --git a/rust/extractor/src/translate/mappings.rs b/rust/extractor/src/translate/mappings.rs
index 6ad8a7d1df6f..d10d637816b5 100644
--- a/rust/extractor/src/translate/mappings.rs
+++ b/rust/extractor/src/translate/mappings.rs
@@ -1,4 +1,5 @@
-use ra_ap_hir::{Enum, Function, HasContainer, Module, Semantics, Struct, Trait, Union};
+use crate::translate::label_cache::StorableAsModuleItemCanonicalPath;
+use ra_ap_hir::{Adt, Enum, Module, Semantics, Struct, Trait, Union};
 use ra_ap_ide_db::RootDatabase;
 use ra_ap_syntax::{ast, ast::RangeItem, AstNode};
 
@@ -52,155 +53,91 @@ impl TextValue for ast::RangePat {
         self.op_token().map(|x| x.text().to_string())
     }
 }
-
-pub(crate) trait AddressableHir<Ast: AstNode>: HasContainer + Copy {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String>;
-    fn try_from_source(value: &Ast, sema: &Semantics<'_, RootDatabase>) -> Option<Self>;
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module;
+pub trait PathAst: AstNode {
+    fn path(&self) -> Option<ast::Path>;
 }
 
-impl AddressableHir<ast::Fn> for Function {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        Some(self.name(sema.db).as_str().to_owned())
-    }
-
-    fn try_from_source(value: &ast::Fn, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_fn_def(value)
-    }
-
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module {
-        self.module(sema.db)
+impl PathAst for ast::PathExpr {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
     }
 }
 
-impl AddressableHir<ast::Trait> for Trait {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        Some(self.name(sema.db).as_str().to_owned())
-    }
-
-    fn try_from_source(value: &ast::Trait, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_trait_def(value)
-    }
-
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module {
-        self.module(sema.db)
+impl PathAst for ast::RecordExpr {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
     }
 }
 
-impl AddressableHir<ast::Module> for Module {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        self.name(sema.db).map(|s| s.as_str().to_owned())
-    }
-
-    fn try_from_source(value: &ast::Module, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_module_def(value)
-    }
-
-    fn module(self, _sema: &Semantics<'_, RootDatabase>) -> Module {
-        self
+impl PathAst for ast::PathPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
     }
 }
 
-impl AddressableHir<ast::Struct> for Struct {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        Some(self.name(sema.db).as_str().to_owned())
-    }
-
-    fn try_from_source(value: &ast::Struct, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_struct_def(value)
+impl PathAst for ast::RecordPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
     }
+}
 
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module {
-        self.module(sema.db)
+impl PathAst for ast::TupleStructPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
     }
 }
 
-impl AddressableHir<ast::Enum> for Enum {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        Some(self.name(sema.db).as_str().to_owned())
-    }
+pub trait ModuleItem: StorableAsModuleItemCanonicalPath {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module;
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String;
+}
 
-    fn try_from_source(value: &ast::Enum, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_enum_def(value)
+impl ModuleItem for Adt {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Adt::module(*self, sema.db)
     }
 
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module {
-        self.module(sema.db)
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Adt::name(*self, sema.db).as_str().to_owned()
     }
 }
 
-impl AddressableHir<ast::Union> for Union {
-    fn name(self, sema: &Semantics<'_, RootDatabase>) -> Option<String> {
-        Some(self.name(sema.db).as_str().to_owned())
-    }
-
-    fn try_from_source(value: &ast::Union, sema: &Semantics<'_, RootDatabase>) -> Option<Self> {
-        sema.to_union_def(value)
+impl ModuleItem for Enum {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Enum::module(*self, sema.db)
     }
 
-    fn module(self, sema: &Semantics<'_, RootDatabase>) -> Module {
-        self.module(sema.db)
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Enum::name(*self, sema.db).as_str().to_owned()
     }
 }
 
-pub(crate) trait AddressableAst: AstNode + Sized {
-    type Hir: AddressableHir<Self>;
-}
-
-impl AddressableAst for ast::Fn {
-    type Hir = Function;
-}
-
-impl AddressableAst for ast::Trait {
-    type Hir = Trait;
-}
-
-impl AddressableAst for ast::Struct {
-    type Hir = Struct;
-}
-
-impl AddressableAst for ast::Enum {
-    type Hir = Enum;
-}
-
-impl AddressableAst for ast::Union {
-    type Hir = Union;
-}
-
-impl AddressableAst for ast::Module {
-    type Hir = Module;
-}
-
-pub trait PathAst: AstNode {
-    fn path(&self) -> Option<ast::Path>;
-}
+impl ModuleItem for Struct {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Struct::module(*self, sema.db)
+    }
 
-impl PathAst for ast::PathExpr {
-    fn path(&self) -> Option<ast::Path> {
-        self.path()
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Struct::name(*self, sema.db).as_str().to_owned()
     }
 }
 
-impl PathAst for ast::RecordExpr {
-    fn path(&self) -> Option<ast::Path> {
-        self.path()
+impl ModuleItem for Union {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Union::module(*self, sema.db)
     }
-}
 
-impl PathAst for ast::PathPat {
-    fn path(&self) -> Option<ast::Path> {
-        self.path()
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Union::name(*self, sema.db).as_str().to_owned()
     }
 }
 
-impl PathAst for ast::RecordPat {
-    fn path(&self) -> Option<ast::Path> {
-        self.path()
+impl ModuleItem for Trait {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Trait::module(*self, sema.db)
     }
-}
 
-impl PathAst for ast::TupleStructPat {
-    fn path(&self) -> Option<ast::Path> {
-        self.path()
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Trait::name(*self, sema.db).as_str().to_owned()
     }
 }
diff --git a/rust/extractor/src/trap.rs b/rust/extractor/src/trap.rs
index 6c8e9b2c3c84..50e7da4034b2 100644
--- a/rust/extractor/src/trap.rs
+++ b/rust/extractor/src/trap.rs
@@ -1,13 +1,13 @@
 use crate::config::Compression;
 use crate::{config, generated};
 use codeql_extractor::{extractor, file_paths, trap};
+use itertools::Itertools;
 use log::debug;
 use ra_ap_ide_db::line_index::LineCol;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
-
 pub use trap::Label as UntypedLabel;
 pub use trap::Writer;
 
@@ -122,6 +122,24 @@ impl<T: TrapClass> From<Label<T>> for trap::Arg {
     }
 }
 
+impl<T: TrapClass> AsTrapKeyPart for Option<Label<T>> {
+    fn as_key_part(&self) -> String {
+        format!("[{}]", self.map(|l| l.as_key_part()).unwrap_or_default())
+    }
+}
+
+impl AsTrapKeyPart for Option<String> {
+    fn as_key_part(&self) -> String {
+        format!("[{}]", self.as_ref().map(|s| s.as_str()).unwrap_or(""))
+    }
+}
+
+impl<T: TrapClass> AsTrapKeyPart for Vec<Label<T>> {
+    fn as_key_part(&self) -> String {
+        format!("[{}]", self.iter().map(|l| l.as_key_part()).join(","))
+    }
+}
+
 pub struct TrapFile {
     path: PathBuf,
     pub writer: Writer,
diff --git a/rust/ql/.generated.list b/rust/ql/.generated.list
index 264205ee9145..8364820ba391 100644
--- a/rust/ql/.generated.list
+++ b/rust/ql/.generated.list
@@ -1,6 +1,6 @@
 lib/codeql/rust/controlflow/internal/generated/CfgNodes.qll 12a240e8392e4b0ad9ddb8067b25a1b5e4c1151886d9d64292a7a9ff29d11d97 fdbe7ca4f085d04371280299fd10a604ee5a059294d2c4c836f334d2b5f8926d
 lib/codeql/rust/elements/Abi.qll 4c973d28b6d628f5959d1f1cc793704572fd0acaae9a97dfce82ff9d73f73476 250f68350180af080f904cd34cb2af481c5c688dc93edf7365fd0ae99855e893
-lib/codeql/rust/elements/Addressable.qll 13011bfd2e1556694c3d440cc34af8527da4df49ad92b62f2939d3699ff2cea5 ddb25935f7553a1a384b1abe2e4b4fa90ab50b952dadec32fd867afcb054f4be
+lib/codeql/rust/elements/Addressable.qll eec6bd2a4aa5ea56b7e2fe291a7732cfa0641247de09aefd482fdf14804a2747 138e598085598bf2afd39d33bd1d81d267c769abef0778099e48a8d96f423cd2
 lib/codeql/rust/elements/ArgList.qll 661f5100f5d3ef8351452d9058b663a2a5c720eea8cf11bedd628969741486a2 28e424aac01a90fb58cd6f9f83c7e4cf379eea39e636bc0ba07efc818be71c71
 lib/codeql/rust/elements/ArrayExpr.qll e4e7cff3518c50ec908271906dd46c1fbe9098faa1e8cd06a27f0a6e8d165ed1 fe02a4f4197f57ecd1e8e82d6c9384148ec29d8b106d7f696795b2f325e4a71b
 lib/codeql/rust/elements/ArrayListExpr.qll 451aedcecb479c385ff497588c7a07fda304fd5b873270223a4f2c804e96b245 a8cb008f6f732215623b5626c84b37b651ca01ccafb2cf4c835df35d5140c6ad
@@ -126,7 +126,7 @@ lib/codeql/rust/elements/RefExpr.qll 91a0d3a86002289dc01ffbe8daca13e34e92e522fbb
 lib/codeql/rust/elements/RefPat.qll fe076bdccb454111b38f360837d180274ba8a003b4cffe910b5197cd74188089 2604c8bb2b0b47091d5fc4aa276de46fe3561e346bd98f291c3783cef402ba06
 lib/codeql/rust/elements/RefTypeRepr.qll ac41d8b4132f273d65873ea3c59631bc1718b3266ae08075346e6cb1bfe2f17c b7e34851d37008806d4519105a5e3405dda07b999294c6656a0c447ac1635b2a
 lib/codeql/rust/elements/Rename.qll 55fa06145f2160304caac0a5ce4cf6a496e41adfd66f44b3c0a1d23229ed8ce0 80262f0abf61749cdf0d5701637db359960f5404ad1dbfdd90f5048d2e7c315d
-lib/codeql/rust/elements/Resolvable.qll efeec2b4b14d85334ec745b9a0c5aa6f7b9f86fe3caa45b005dccaee4f5265c4 7efe0063340ba61dd31125bc770773ca23a7067893c0d1e06d149da6e9a9ee92
+lib/codeql/rust/elements/Resolvable.qll d18e3434f208085a4418c9e41d4451e1d22d400473fd43160892c37075450832 ea0e7f5e45ead2569f0ddddd56c6d0bff7c4133e6f5bff5d05ccce977cfa3371
 lib/codeql/rust/elements/RestPat.qll a898a2c396f974a52424efbc8168174416ac6ed30f90d57c81646d2c08455794 db635ead3fa236e45bbd9955c714ff0abb1e57e1ce80d99dc5bb13438475adbf
 lib/codeql/rust/elements/RetTypeRepr.qll a95a053e861a8d6e5e8eda531f29c611b00904d48ea2bb493138d94d39096ace ebde4f865d310351ba6ee71852428819627ea3909e341d6800ab268b1810c6fa
 lib/codeql/rust/elements/ReturnExpr.qll b87187cff55bc33c8c18558c9b88617179183d1341b322c1cab35ba07167bbdb 892f3a9df2187e745c869e67f33c228ee42754bc9e4f8f4c1718472eb8f8c80f
@@ -172,9 +172,46 @@ lib/codeql/rust/elements/WhileExpr.qll 9e0c23057bf3fa3e050d5f6de0650f554ce576861
 lib/codeql/rust/elements/WildcardPat.qll 4f941afc5f9f8d319719312399a8f787c75a0dbb709ec7cf488f019339635aab a9140a86da752f9126e586ddb9424b23b3fb4841a5420bac48108c38bb218930
 lib/codeql/rust/elements/YeetExpr.qll 4172bf70de31cab17639da6eed4a12a7afcefd7aa9182216c3811c822d3d6b17 88223aab1bef696f508e0605615d6b83e1eaef755314e6a651ae977edd3757c3
 lib/codeql/rust/elements/YieldExpr.qll de2dc096a077f6c57bba9d1c2b2dcdbecce501333753b866d77c3ffbe06aa516 1f3e8949689c09ed356ff4777394fe39f2ed2b1e6c381fd391790da4f5d5c76a
+lib/codeql/rust/elements/canonical_paths/BuiltinTypeCanonicalPath.qll 2a80efb538218b5b3d36fcf76a7f4a58dfebf5f808df80fa13d914cebc08d115 3119e65f672038218587a3651a2ed621f9ad85d36748b51eb0674c4e5a203f24
+lib/codeql/rust/elements/canonical_paths/CanonicalPath.qll b560482aefdc6206bec91941eafc7444858eed30ed7e26d8a52a44704f3a3bd9 75cdb532d3d92ecf0a5a7f24b48ae2470d82b5fa93bf4dbf56c678d03580b445
+lib/codeql/rust/elements/canonical_paths/CanonicalPathElement.qll 8dd4ad94281238cfad2ffc69b5115c05076c998f4b46cff0cdafd0cc00e1c49b 274274bcd55f79fbb1af5e5d34be9a59e1e0baf37298f7d3a8541e8a116ffba8
+lib/codeql/rust/elements/canonical_paths/ConcreteTypeCanonicalPath.qll 720734f277ae81ea6a2c07af8ddc5a8b00aa5ff3ee008e8ab9c7bcef0b974fcc ffbe408309847a5d57b1e83504d192756a58af945b758c812e4cb98280af68ec
+lib/codeql/rust/elements/canonical_paths/ConstGenericTypeArg.qll c20adef6f5dce4707c3eae6d62c1c5fec504479c12698f8772bc9a47de862204 dde369301c39faf01773704b29863257c87577015c21da8f4cb360d6799a0cc2
+lib/codeql/rust/elements/canonical_paths/CrateRef.qll d8477ae2c6b3509304f09f6654b27c365bf6521f92616571a0fa3d3c3fb84cb9 7a4bd96a62174f2931d6ac8c2cb78c2932d4518795936bcdf7ef13fd54c354ea
+lib/codeql/rust/elements/canonical_paths/DerivedTypeCanonicalPath.qll 74d633f843d4370a5b138bdd1dd055299f34bf4a35d4b5aff3b3989e03902fdd 2e59fcca32927ef0dceb07b882636abb93c3391f8ce00859b3866ab63b255e1c
+lib/codeql/rust/elements/canonical_paths/LangCrateRef.qll 46883e818e02c8044ce0aec6690ec4ace7a2623c787b47187d23ab1d17acac99 6a7b570ce9909f198fa7dbda9c2a34b133346c0de576e2d04949be5682457f47
+lib/codeql/rust/elements/canonical_paths/ModuleItemCanonicalPath.qll a2c1de98457b46e7b23ce883a4f7d89ad568916bcd1f9b952b5c533ebacf4300 4baeb47b9a5ce63fe038414f922056aa4e54f684d33c5348072218a121259925
+lib/codeql/rust/elements/canonical_paths/Namespace.qll 697215274278c7be4ae05aaff5aed6b0295939223f61f15bc0a9bf5c24a5883e 4ecad978ea9f07754481f2d307272bd543abb2be406a8767ac37b9fc6b75254c
+lib/codeql/rust/elements/canonical_paths/ParametrizedCanonicalPath.qll a22d55c98080b4b4f0db8882ff942919394b709e4b611b1107b0ab6f6d6968ab d2d72ed915d2eb1485762644d34193093e7ed525cb63eb9cbfa082135bb1108f
+lib/codeql/rust/elements/canonical_paths/PlaceholderTypeCanonicalPath.qll ff1be7f5267ceccf40d286c19b4b7933d625cff1bc992c4bbd7d8ca9e584ce93 b89e3bec9d3e2baecd7e76852688f9926b63a0006662778484e139fe2dec10f5
+lib/codeql/rust/elements/canonical_paths/RepoCrateRef.qll a71260681908504abaa272e7ef0b82aef6c40d7bd1edf45feb55b67370e6d7d0 650461bc0bdaf121f8d3617e596c45019719e599724c19712e7879c399348c3e
+lib/codeql/rust/elements/canonical_paths/RustcCrateRef.qll a360a20c6afd3a4469248523d3ea23dcb3f6678542e4bdf69356e58b19155990 c41c2530b0db33b568c1ea279a5e1b102d31632540b8d2cb70d56a945c2e8a03
+lib/codeql/rust/elements/canonical_paths/TraitImplItemCanonicalPath.qll c0a645274554605e53df715df9e4c8900118463a252892a7e88633b378ceddae 1c906216e8afd03414ea47888fe1b33c2c57fac8fcc1f0230334fae3808b43ba
+lib/codeql/rust/elements/canonical_paths/TypeCanonicalPath.qll 510f0c11ca8ac95ee8be57a0be18d2e7ce6350d8ab966e14eeb5a878d1acc781 ae68660f4f24f6426cdf32eeae065fe32d82d1ddece356b10cbbd5579a81e45a
+lib/codeql/rust/elements/canonical_paths/TypeGenericArg.qll 551e5bce7b474ff097dedfe80e52ca0b3808bda3c855961daddd0ecf36f67aef f3ac937ce08484edab04f285e459c77aac4552e8513b7ee124653aafdb3ceffc
+lib/codeql/rust/elements/canonical_paths/TypeGenericTypeArg.qll a8a31940baf116b4a41ab2316e995cedac2d0516c546898e028a63f23ea7cb63 b5df2d469245e507b7d2d35263be9f4d7229e6a7914199bf2eae938a1202dfe8
+lib/codeql/rust/elements/canonical_paths/TypeImplItemCanonicalPath.qll a482bf323d0f750ace7ba4df99ef2aed009b5c135d24d4f61c7b33d5fa7c5037 1f72d5a781f7c4986b8927811977093dc39bfa37067a00e320b109bca1aae840
+lib/codeql/rust/elements/canonical_paths/TypeItemCanonicalPath.qll 3cdd980844dac4533bf7fc82c1679af39b151aecbe325a9dbd7a2275ecc3b72b df6232001508086a62ad0e629287d0705a072ba26437f8a55d8aad977e11f554
+lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathConstructor.qll c33ca6a182eae907bc01a11bbe9e10a705889d6d383cd8804c5380368cf785d4 af1677ff43fcb22dedde3dfa853dc12a197c6e5db7ec6191cfd6c9197e371a05
+lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathImpl.qll 6dbc6981e280717eb8a7cc2bf06bb91e760cc168e262dcf87db53f610b3a0362 ce81251f033173baabcfa9dd2a6a760169015329daac738760bb4e6689c0fe85
+lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathConstructor.qll 122781ed5b5bfddc0f6c5243d3a77eb969559115c7f612b81291f62b5790b48d 348ee1d8c92b803a1aaf8e3fc5a9061a41cd2a4c6f2f6fa51910659a1edfa00f
+lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgConstructor.qll a2ef92745e712b091367e063662e800b8f84efdf28b02e7116c7c8ab0629e0fc 4a2689f585c0de2f77ca64620bb65986bafab6209fbc383646335040d6155018
+lib/codeql/rust/elements/canonical_paths/internal/CrateRefImpl.qll 2ee10df29ad819573586e12def0bc4dfe3eb4cf57e2c414ff2d606fb1833b6be 366fe98f3a11ead09aea9aa78b15f4392da641d4ba93a1661bcf0a4816b145d5
+lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathConstructor.qll 1127f0e1eaed5da946a5288271f679ef1984d984a3686cd59d9ec89a8251a234 04419a1231179c8d39637edd443c4ff038e010753f4e6a016ac8c9dbc8f6cccd
+lib/codeql/rust/elements/canonical_paths/internal/LangCrateRefConstructor.qll 068e498ca6e1f0847ad08705e5904a3d1cee9646da3e71e64c565e98bf5de0b8 3a629031633c1f31537ac563e3c3da488dc7e657e20765c6fee0457518075089
+lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathConstructor.qll fc580aff51cf598ecfc61a8476044c69800d1bbc41ce5a7ddf1c773d9c20c5db 03ca4ddd5703f2c98609044f76d63c36607b59f25e1e21137818ca7291bb5baf
+lib/codeql/rust/elements/canonical_paths/internal/NamespaceConstructor.qll 31a7578929de91094425f88d5739a5264c17986e2a00b117075f329cbbef79b6 faf500f1e2a1b04d0bd949d32a639c8713052813cde33aa9cbd691b34a802aac
+lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathConstructor.qll b9e0bd9380f998e6d7bfbc7d94bdfbfb6d38807bb9e16272c79456725789ee45 c91ac59709ab9f8c4b14d611e532b950479cd4652b6fcde140489b15b19b8a0d
+lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathConstructor.qll 8c746f1b034a1f88eaa17244669d87891234a4149ce01139f2485a173802ce93 9d7317406fb9112998bee96f90cec9fbfb24f57497d0ea769e9e944c2aaeddd3
+lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRefConstructor.qll 215cdb759bf908392e89bde7dd0e8e82b7c6028ecaf3e8844b4a89e0188f86de 8ae1500a7d5c91f6af919148f525c14defc2c71ef825f095d011785471549317
+lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRefConstructor.qll 7504c2625ce3cf33abdb120767926f413caa53275ccc97d5331b549e838e1e50 c183b8846b791404b14a11a3f9d973827747cece903101d1b21b12a56e164b03
+lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathConstructor.qll 4548d2fb262c646ff2eb0409390b9360bcec2bd4a9b594817129f84b6215f362 3d593cf26f40379dda22bb449d05c53c12dad74c06ca4beec1fc59c50362ea67
+lib/codeql/rust/elements/canonical_paths/internal/TypeCanonicalPathImpl.qll a6c0228c980b0e8874ccc8d278b4f2938db94ff6a40f065ba2fca5ea012682c6 6a0e7c9d0ea701b605aa19f71f6eeb928e1ab4df9b1961b337ad56e02e36a599
+lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgConstructor.qll dcc4210aa0ed7c2aadd8dfb1f343b29cdf4cfd8d54bddd4424b90f97eac18bf4 b5ce26d604c7e84f27f5981b45b0462e7746089c29522e13ca481e388503d446
+lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathConstructor.qll 4ff55c5fefada4209d9dde9c4a1eaa0d35ca3b1466b309e45c66d63aa96b529b 4f3ec452a35a5d16f4e61e8203d79c6af90ae74cc0c2a32579ce38e22aa8d1f0
+lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathConstructor.qll b23c6d7902c56c758bc121cd5d3c7e351eccb66503131bc2fa4dda60abb9b4ae b097ab6555f06b12f7ae99378dc9bc347a8b7b7b2691d6a636b9392178cb5692
 lib/codeql/rust/elements/internal/AbiConstructor.qll 4484538db49d7c1d31c139f0f21879fceb48d00416e24499a1d4b1337b4141ac 460818e397f2a1a8f2e5466d9551698b0e569d4640fcb87de6c4268a519b3da1
 lib/codeql/rust/elements/internal/AbiImpl.qll 01439712ecadc9dc8da6f74d2e19cee13c77f8e1e25699055da675b2c88cb02d dcc9395ef8abd1af3805f3e7fcbc2d7ce30affbce654b6f5e559924768db403c
-lib/codeql/rust/elements/internal/AddressableImpl.qll e01a6104980960f5708d5a0ada774ba21db9a344e33deeaf3d3239c627268c77 b8bfc711b267df305ac9fe5f6a994f051ddeca7fc95dacd76d1bae2d4fa7adde
 lib/codeql/rust/elements/internal/ArgListConstructor.qll a73685c8792ae23a2d628e7357658efb3f6e34006ff6e9661863ef116ec0b015 0bee572a046e8dfc031b1216d729843991519d94ae66280f5e795d20aea07a22
 lib/codeql/rust/elements/internal/ArgListImpl.qll 19664651c06b46530f0ae5745ccb3233afc97b9152e053761d641de6e9c62d38 40af167e571f5c255f264b3be7cc7f5ff42ec109661ca03dcee94e92f8facfc6
 lib/codeql/rust/elements/internal/ArrayExprInternal.qll 07a219b3d3fba3ff8b18e77686b2f58ab01acd99e0f5d5cad5d91af937e228f5 7528fc0e2064c481f0d6cbff3835950a044e429a2cd00c4d8442d2e132560d37
@@ -417,7 +454,7 @@ lib/codeql/rust/elements/internal/YeetExprImpl.qll e8924147c3ebe0c32d04c5b33edfd
 lib/codeql/rust/elements/internal/YieldExprConstructor.qll 8cbfa6405acb151ee31ccc7c89336948a597d783e8890e5c3e53853850871712 966f685eb6b9063bc359213323d3ff760b536158ecd17608e7618a3e9adf475f
 lib/codeql/rust/elements/internal/YieldExprImpl.qll af184649a348ddd0be16dee9daae307240bf123ace09243950342e9d71ededd9 17df90f67dd51623e8a5715b344ccd8740c8fc415af092469f801b99caacb70d
 lib/codeql/rust/elements/internal/generated/Abi.qll 87e1ea6b2a8ebf60e1c69176632740e4e27fc56c3f173939b098ba376562b5fa 94b2121e71c4ec94d53a79f972c05a8484ef0d80ed638f53031e7cf4dc5343d5
-lib/codeql/rust/elements/internal/generated/Addressable.qll 96a8b45166dd035b8d2c6d36b8b67019f2d4d0b4ccff6d492677c0c87197613e d8f1ce29feafc8ff7179399fc7eac5db031a7e1a8bc6b2cd75cfce1da3132e9b
+lib/codeql/rust/elements/internal/generated/Addressable.qll f441fd5ea1a50be728f42a2a125dcdaa74616f8b0b3266176b0e653baad5e705 413013650bf6303f974c7b95ba19e823173c3c138f362a44307d1a0b88efc01f
 lib/codeql/rust/elements/internal/generated/ArgList.qll 1b75b2d7dcf524eb468a0268af6293e9d17832d6bedf3feec49a535824339b57 2bcaf464454bdfdda45fbd24d063f0f1df0eb69f684197b37105adc8f72cd1ea
 lib/codeql/rust/elements/internal/generated/ArrayExpr.qll 73806a0de8168b38a9436fa6b8c6d68c92eeab3d64a1ae7edfff82f871929992 7ad998cdd8f4fed226473517ad7a5765cb35608033047aad53bf8aa3969fd03b
 lib/codeql/rust/elements/internal/generated/ArrayExprInternal.qll 67a7b0fae04b11cf771727ff39a123fb2d5ce6e2d650d32478fcb33a26ed5688 15833405fa85f6abe0e5146dac283cb5a142a07f08300ccc15a1dae30ed88942
@@ -521,7 +558,7 @@ lib/codeql/rust/elements/internal/generated/ParamList.qll c808c9d84dd7800573832b
 lib/codeql/rust/elements/internal/generated/ParenExpr.qll bc0731505bfe88516205ec360582a4222d2681d11342c93e15258590ddee82f2 d4bd6e0c80cf1d63746c88d4bcb3a01d4c75732e5da09e3ebd9437ced227fb60
 lib/codeql/rust/elements/internal/generated/ParenPat.qll 4f168ef5d5bb87a903251cc31b2e44a759b099ec69c90af31783fbb15778c940 0e34f94a45a13396fd57d94c245dc64d1adde2ab0e22b56946f7e94c04e297fc
 lib/codeql/rust/elements/internal/generated/ParenTypeRepr.qll 40ab5c592e7699c621787793743e33988de71ff42ca27599f5ab3ddb70e3f7d8 12c0a6eed2202ee3e892f61da3b3ce77ac3190854cdf3097e8d2be98aa3cb91d
-lib/codeql/rust/elements/internal/generated/ParentChild.qll 876e28befd6a93666832de01342c6df403efb5cbea36d3c4b5d5cc2f34c54d6c 3448847608c25b100328bd68f70730a7e43b7d8b5ef8ab1ce40ae3f5a57c6bd2
+lib/codeql/rust/elements/internal/generated/ParentChild.qll d23340fcdef1a131abe03badd641b2de528b35e4a6f428977334047a276c5801 5888015d46a57dcb7c7707ae5fef9db1cbf33692e6c3a3a3b8d9f1ddbef62b3c
 lib/codeql/rust/elements/internal/generated/Pat.qll 3605ac062be2f294ee73336e9669027b8b655f4ad55660e1eab35266275154ee 7f9400db2884d336dd1d21df2a8093759c2a110be9bf6482ce8e80ae0fd74ed4
 lib/codeql/rust/elements/internal/generated/Path.qll bf6a86e7fcb7164624cc070dcce86d2bda50a2516b95115b87d0ebb5596e50a1 fd7a9ad4034cdebe8dfe495619c46f464630d38195313072e0bd904061b0fb00
 lib/codeql/rust/elements/internal/generated/PathAstNode.qll e6d4d5bffd3c623baaaee46bc183eb31ce88795535f164f6a9b9b4d98bbd6101 168db515404933479ba6b150c72e012d28592cbc32366aefcb1bf9599dbcd183
@@ -535,7 +572,7 @@ lib/codeql/rust/elements/internal/generated/PtrTypeRepr.qll 51d1e9e683fc79dddbff
 lib/codeql/rust/elements/internal/generated/PureSynthConstructors.qll e5b8e69519012bbaae29dcb82d53f7f7ecce368c0358ec27ef6180b228a0057f e5b8e69519012bbaae29dcb82d53f7f7ecce368c0358ec27ef6180b228a0057f
 lib/codeql/rust/elements/internal/generated/RangeExpr.qll 23cca03bf43535f33b22a38894f70d669787be4e4f5b8fe5c8f7b964d30e9027 18624cef6c6b679eeace2a98737e472432e0ead354cca02192b4d45330f047c9
 lib/codeql/rust/elements/internal/generated/RangePat.qll 80826a6a6868a803aa2372e31c52a03e1811a3f1f2abdb469f91ca0bfdd9ecb6 34ee1e208c1690cba505dff2c588837c0cd91e185e2a87d1fe673191962276a9
-lib/codeql/rust/elements/internal/generated/Raw.qll b295dd46979a2d4df840e1bef4ba12e3b4ff58aa886c8a1320281739d36c5a4f 2369cba6d70f0e853acb0e018dfb47e604ee01dca48af7094b484a7e18a46365
+lib/codeql/rust/elements/internal/generated/Raw.qll 16ce13a21bdde691e2856deef2734ba23c85a9a0f9a882206ddc711ce7106755 6a69912b39e8da4e9b6ff1b61b147c313675ccdb96de73d51c4dca4b6a60f344
 lib/codeql/rust/elements/internal/generated/RecordExpr.qll 2131b2cb336caa76170082e69776011bf02576bbfdd34ba68ca84af24209250a 39a2e3ec32352b594c43cc1295e0e8b3f9808173322d3d73cb7d48ef969d5565
 lib/codeql/rust/elements/internal/generated/RecordExprField.qll 7e9f8663d3b74ebbc9603b10c9912f082febba6bd73d344b100bbd3edf837802 fbe6b578e7fd5d5a6f21bbb8c388957ab7210a6a249ec71510a50fb35b319ea1
 lib/codeql/rust/elements/internal/generated/RecordExprFieldList.qll 179a97211fe7aa6265085d4d54115cdbc0e1cd7c9b2135591e8f36d6432f13d3 dd44bbbc1e83a1ed3a587afb729d7debf7aeb7b63245de181726af13090e50c0
@@ -548,7 +585,7 @@ lib/codeql/rust/elements/internal/generated/RefExpr.qll 7d995884e3dc1c25fc719f5d
 lib/codeql/rust/elements/internal/generated/RefPat.qll 456ede39837463ee22a630ec7ab6c8630d3664a8ea206fcc6e4f199e92fa564c 5622062765f32930465ba6b170e986706f159f6070f48adee3c20e24e8df4e05
 lib/codeql/rust/elements/internal/generated/RefTypeRepr.qll 3d8c0bd296d33b91a81633f697a43269a6538df06d277262d3990d3f6880ef57 13680f39e89bcd8299c218aba396f3deec804597e6f7cb7d4a7e7c748b6faa77
 lib/codeql/rust/elements/internal/generated/Rename.qll d23f999dab4863f9412e142756f956d79867a3579bd077c56993bdde0a5ac2f1 9256c487d3614bf3d22faa294314f490cf312ab526b8de0882e3a4a371434931
-lib/codeql/rust/elements/internal/generated/Resolvable.qll 586eefb01794220679c3b5d69c059d50c2238cf78ab33efe7185bbd07dea8dbd 1b7c7297d541b9de9e881d18fed4ae40dd327396366a3a6f52a24b85685fa9c1
+lib/codeql/rust/elements/internal/generated/Resolvable.qll 19f90b2f4d17ec4343b303b6dcef18c60dfccce9bceb7bdde1507014f929326a 3eccee14e107f2aeb490b80014fe2a38d2a5ba8b6b40dbd30ab67e1122b8f390
 lib/codeql/rust/elements/internal/generated/RestPat.qll 234bbaa8aa37962c9138baf5b1f4406c3d78f4131b4b8dbb30fc1343d15873d5 653ee6bea4d3cf9454b2834bc4233a8f275295f19635c37a0bca69a587e1eb20
 lib/codeql/rust/elements/internal/generated/RetTypeRepr.qll 173fd722308161f9405f929a13718134f8eaefe9fce1686048860b7c8f4c29f7 30bbaada842369dac5618ae573999f59979597c6a3315c6cce04e5bed0b38c87
 lib/codeql/rust/elements/internal/generated/ReturnExpr.qll c9c05400d326cd8e0da11c3bfa524daa08b2579ecaee80e468076e5dd7911d56 e7694926727220f46a7617b6ca336767450e359c6fa3782e82b1e21d85d37268
@@ -561,8 +598,8 @@ lib/codeql/rust/elements/internal/generated/Static.qll ea22838e0b7d9796dfaf5deda
 lib/codeql/rust/elements/internal/generated/Stmt.qll 8473ff532dd5cc9d7decaddcd174b94d610f6ca0aec8e473cc051dad9f3db917 6ef7d2b5237c2dbdcacbf7d8b39109d4dc100229f2b28b5c9e3e4fbf673ba72b
 lib/codeql/rust/elements/internal/generated/StmtList.qll a667193e32341e17400867c6e359878c4e645ef9f5f4d97676afc0283a33a026 a320ed678ee359302e2fc1b70a9476705cd616fcfa44a499d32f0c7715627f73
 lib/codeql/rust/elements/internal/generated/Struct.qll 4d57f0db12dc7ad3e31e750a24172ef1505406b4dab16386af0674bd18bf8f4b 1a73c83df926b996f629316f74c61ea775be04532ab61b56af904223354f033e
-lib/codeql/rust/elements/internal/generated/Synth.qll b6d4e3f5fa38d7eca94495447b591fa9ed44cb5fcb4982077d54c8227d898401 a145534947c98e6dba0ba6d92d46f3eef34d01ce8b60d4b699db8bacc63c3c5b
-lib/codeql/rust/elements/internal/generated/SynthConstructors.qll 3ceb5f6ee40b94955ce5f47feb454cc9129941aad3cdbe6e337bbe41e76a8a23 3ceb5f6ee40b94955ce5f47feb454cc9129941aad3cdbe6e337bbe41e76a8a23
+lib/codeql/rust/elements/internal/generated/Synth.qll a1341446083fa92d7eab01cb80b79ef71fe81974cb848152a87e5a8f54b63dd6 c9254ea4bd48ce66c8a2717bf811cfc99fbbb83b9de6e98c33957a651c76d3ea
+lib/codeql/rust/elements/internal/generated/SynthConstructors.qll 2239b4c8ab67d2c4816767d86a2e96609a17e81bd397cc7a46147b81e5e94f61 2239b4c8ab67d2c4816767d86a2e96609a17e81bd397cc7a46147b81e5e94f61
 lib/codeql/rust/elements/internal/generated/Token.qll 77a91a25ca5669703cf3a4353b591cef4d72caa6b0b9db07bb9e005d69c848d1 2fdffc4882ed3a6ca9ac6d1fb5f1ac5a471ca703e2ffdc642885fa558d6e373b
 lib/codeql/rust/elements/internal/generated/TokenTree.qll 8577c2b097c1be2f0f7daa5acfcf146f78674a424d99563e08a84dd3e6d91b46 d2f30764e84dbfc0a6a5d3d8a5f935cd432413688cb32da9c94e420fbc10665c
 lib/codeql/rust/elements/internal/generated/Trait.qll 8fa41b50fa0f68333534f2b66bb4ec8e103ff09ac8fa5c2cc64bc04beafec205 ce1c9aa6d0e2f05d28aab8e1165c3b9fb8e24681ade0cf6a9df2e8617abeae7e
@@ -596,7 +633,27 @@ lib/codeql/rust/elements/internal/generated/WhileExpr.qll 7edf1f23fbf953a2baabcd
 lib/codeql/rust/elements/internal/generated/WildcardPat.qll d74b70b57a0a66bfae017a329352a5b27a6b9e73dd5521d627f680e810c6c59e 4b913b548ba27ff3c82fcd32cf996ff329cb57d176d3bebd0fcef394486ea499
 lib/codeql/rust/elements/internal/generated/YeetExpr.qll cac328200872a35337b4bcb15c851afb4743f82c080f9738d295571eb01d7392 94af734eea08129b587fed849b643e7572800e8330c0b57d727d41abda47930b
 lib/codeql/rust/elements/internal/generated/YieldExpr.qll 37e5f0c1e373a22bbc53d8b7f2c0e1f476e5be5080b8437c5e964f4e83fad79a 4a9a68643401637bf48e5c2b2f74a6bf0ddcb4ff76f6bffb61d436b685621e85
-lib/codeql/rust/elements.qll 2b46fa94e6775759fb730da818e0bf66e0f434c7e3d49f0e1989a5e5e6e48fd2 2b46fa94e6775759fb730da818e0bf66e0f434c7e3d49f0e1989a5e5e6e48fd2
+lib/codeql/rust/elements/internal/generated/canonical_paths/BuiltinTypeCanonicalPath.qll a27755a5093cf063ad3dfb86d62212cd219ad3b8890eac1836077c1112f3e869 1a15e92ecdb194338319aa11060f9cf5b753a1dd0236b274c351bb78d4bec063
+lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPath.qll d2af9c90308939762fc5a9c0629da4b9bbab13f6b05e0353ff5575d659768392 2c03df5ef7d29d9a80e96ed43395e8120ee93d5075b9174d247300d26e563a5d
+lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPathElement.qll 61446d0f3bcd327bad6b31c3c60c62571feaf862b31dda6474e01c8f37e8059a 33f2827acb058317b7c493fcb66a5b4bb434ac9ad739bbd449da971e72cb480f
+lib/codeql/rust/elements/internal/generated/canonical_paths/ConcreteTypeCanonicalPath.qll 4401616f47a95cccec68199bb49c18442a78dde023832f8fd5e16c73219baede 12f65fd81dc20ff5f4b74dac2232818fe75cb2e7f9abfdcae2177acc620b2c0f
+lib/codeql/rust/elements/internal/generated/canonical_paths/ConstGenericTypeArg.qll 69aae3c8c9d0ba87d543e6cec3d8783950b31888a6da15e5be37da81c7690238 780a9afc1e43ec885afc2ea22259c4f417244a7efcfb8dd3dc6209462e5faffc
+lib/codeql/rust/elements/internal/generated/canonical_paths/CrateRef.qll be30f2bf11f46fea8fcf79baa3adacb41d9fbb168e13b106c649224f13cb11f0 2a25d7abad55733041812c43ed4be62f99f971169fd6bc3a6dd49b778f0edd7f
+lib/codeql/rust/elements/internal/generated/canonical_paths/DerivedTypeCanonicalPath.qll 8e57c57332da344c2b5d9fcdbd079da0f8e322d500b953c5ddeac12dd783fb6f 57224ed02e4e1ada6b01dfa58953bdd7f13cab06d55b90957e64d9d1accead0a
+lib/codeql/rust/elements/internal/generated/canonical_paths/LangCrateRef.qll 090d102edab5641410ac9285197b610bb16ace28b79e7d27903fcb6e3681aea5 ce9e6129f8b8a937a8a2f62d1bd3fbe38b45514fd2be25b2ea1ffd3bbf447815
+lib/codeql/rust/elements/internal/generated/canonical_paths/ModuleItemCanonicalPath.qll 0b31c6cff057a402051b44ea06a1224c107d8255848c028dbb48c5d8d5e92544 0e157a31e92d6cb9ac4a4cc828b204144def6511ff9fa9002f95b43064cb81e2
+lib/codeql/rust/elements/internal/generated/canonical_paths/Namespace.qll 78de0dc991e77dff838ee9bfb0be81d1034842d0e16dec31a49e9f80bbdf6c72 6b625cd29c65bddcd002d31f1ff2a4781378b6a097c274d5d25de9a10606a603
+lib/codeql/rust/elements/internal/generated/canonical_paths/ParametrizedCanonicalPath.qll 5463401f6f8775df8914a913bfba08c69c75172b4cdafae01321c28b3e9bcd2e 9a0a44725b48df6325114821eb69b161c35f46110909aa98beb8208969d84541
+lib/codeql/rust/elements/internal/generated/canonical_paths/PlaceholderTypeCanonicalPath.qll 27d476cb88f57e342d23218402236f6b15079ef773435102deb80bf57846c364 f143115ea2bd1c8805f3cef32cdc0a52ef9bf53a714ae68bf19c8d48e16d21bd
+lib/codeql/rust/elements/internal/generated/canonical_paths/RepoCrateRef.qll 03c32ed288fb60056ee27e56ee4ef90eb348d21dd0eab3086cc8668da01ea009 976f89c5eeb7ffe35951c062fe3f120a21402e3e6c45ea5cad69a3e2626fbf21
+lib/codeql/rust/elements/internal/generated/canonical_paths/RustcCrateRef.qll ef413b97aee48b99d93ad56bab0579fda27cffbd76343b158b0fbecfcd4b5c40 260a89c2af3bf666f229537c8d1306d50eb221ee232e6f39d116cd2026099bc1
+lib/codeql/rust/elements/internal/generated/canonical_paths/TraitImplItemCanonicalPath.qll 48db8a423bbb8c68ab09872dc7a98bfddc7c699d86dc41256f18111bd9579a1c c651f217821dcdde23e06e2ac2ca1c1f87b4170d449c9b4c35c20ebef246e686
+lib/codeql/rust/elements/internal/generated/canonical_paths/TypeCanonicalPath.qll 98251c42bc4163504b8ceec3502075f3551c2f66f61dc046fef4b13149337253 9bd821857a18356ab980d7fb5b1daa9bb42a738499e36e20a2944565b757c49d
+lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericArg.qll 37c3e3bdee579697aa304d7df713249dc22df3068e189c21c182bba32b780622 b6e785b81f5a39c9643598d19b06f2beb2745dc8da63c8c91e50200824b9e8a7
+lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericTypeArg.qll da1d56d3b9a41ac19ead37043e6035c4f42e32a284c0d6d925aadea4bf9691bc 4032024c23cc2910dab4760a2c249ec95324486c32d8f7fac1478e746635e19f
+lib/codeql/rust/elements/internal/generated/canonical_paths/TypeImplItemCanonicalPath.qll a6d5d4b0d4ed8e5ee372ebb5cce9d8f046a319978c276f93daa6ae6fbf3b01e7 170ac3b7625f1ed867c19821105c5e651d69a382cc82706bd0ab3330e2c58fb3
+lib/codeql/rust/elements/internal/generated/canonical_paths/TypeItemCanonicalPath.qll d2007a4ea331957899a5628c8f42794256952e1942f7331d078ac1c28a5f82e4 a385d0e88d8fcb02e6eea60c8970972ff1d4b96467468caf712d6b992f33fd79
+lib/codeql/rust/elements.qll 3c0e06df3106c3355c76b2fc4e7d5e0b35e3779c2891ea239c062c49fd871960 3c0e06df3106c3355c76b2fc4e7d5e0b35e3779c2891ea239c062c49fd871960
 test/extractor-tests/generated/Abi/Abi.ql 7f6e7dc4af86eca3ebdc79b10373988cd0871bd78b51997d3cffd969105e5fdd 2f936b6ca005c6157c755121584410c03e4a3949c23bee302fbe05ee10ce118f
 test/extractor-tests/generated/Abi/Abi_getAbiString.ql a496762fcec5a0887b87023bbf93e9b650f02e20113e25c44d6e4281ae8f5335 14109c7ce11ba25e3cd6e7f1b3fcb4cb00622f2a4eac91bfe43145c5f366bc52
 test/extractor-tests/generated/ArgList/ArgList.ql e412927756e72165d0e7c5c9bd3fca89d08197bbf760db8fb7683c64bb2229bc 043dba8506946fbb87753e22c387987d7eded6ddb963aa067f9e60ef9024d684
@@ -662,11 +719,10 @@ test/extractor-tests/generated/ClosureExpr/ClosureExpr_getClosureBinder.ql cbfcf
 test/extractor-tests/generated/ClosureExpr/ClosureExpr_getParamList.ql 68ce501516094512dd5bfed42a785474583a91312f704087cba801b02ba7b834 eacbf89d63159e7decfd84c2a1dc5c067dfce56a8157fbb52bc133e9702d266d
 test/extractor-tests/generated/ClosureExpr/ClosureExpr_getRetType.ql c95bc7306b2d77aa05a6501b6321e6f1e7a48b7ad422ba082635ab20014288ae fe72d44c9819b42fff49b9092a9fb2bfafde6d3b9e4967547fb5298822f30bc3
 test/extractor-tests/generated/Comment/Comment.ql 5428b8417a737f88f0d55d87de45c4693d81f03686f03da11dc5369e163d977b 8948c1860cde198d49cff7c74741f554a9e89f8af97bb94de80f3c62e1e29244
-test/extractor-tests/generated/Const/Const.ql ef2d2730e08ff6c9e5e8473f654e0b023296c51bc9acfbffd7d4cc5caeed7919 906f8624b10b3fade378d29e34af8537f86d9de16a22a188887ecfc165f5ded9
+test/extractor-tests/generated/Const/Const.ql 9d9abdd6ac043ba3d1ca37ffac75a8fa7a3f4690caaf2c425b369a0d4bfd61f6 c67faeac497fe58e6490dc68ec332ba1c4f0153f0795cef2464b679c7db7f9b1
 test/extractor-tests/generated/Const/Const_getAttr.ql bd6296dab00065db39663db8d09fe62146838875206ff9d8595d06d6439f5043 34cb55ca6d1f44e27d82a8b624f16f9408bae2485c85da94cc76327eed168577
 test/extractor-tests/generated/Const/Const_getBody.ql f50f79b7f42bb1043b79ec96f999fa4740c8014e6969a25812d5d023d7a5a5d8 90e5060ba9757f1021429ed4ec4913bc78747f3fc415456ef7e7fc284b8a0026
-test/extractor-tests/generated/Const/Const_getCrateOrigin.ql f042bf15f9bde6c62d129601806c79951a2a131b6388e8df24b1dc5d17fe89f7 7c6decb624f087fda178f87f6609510907d2ed3877b0f36e605e2422b4b13f57
-test/extractor-tests/generated/Const/Const_getExtendedCanonicalPath.ql 3300b902e1d1f9928cfe918203b87043e13460cfa5348a8c93712d2e26d61ced 71e7b80d3290f17b1c235adaca2c48ae90eb8b2cb24d4c9e6dc66559daf3824c
+test/extractor-tests/generated/Const/Const_getCanonicalPath.ql 7737e999249e6dffcfe4386671b5c45e3916aaf2852bca889371d1c825444b8c e3473de4fcaf4c4d3c63b740a5879caf463a2e44cda5c12874e4110be433cb8f
 test/extractor-tests/generated/Const/Const_getName.ql b876a1964bbb857fbe8852fb05f589fba947a494f343e8c96a1171e791aa2b5e 83655b1fbc67a4a1704439726c1138bb6784553e35b6ac16250b807e6cd0f40c
 test/extractor-tests/generated/Const/Const_getTypeRepr.ql 87c5deaa31014c40a035deaf149d76b3aca15c4560c93dd6f4b1ee5f76714baa f3e6b31e4877849792778d4535bd0389f3afd482a6a02f9ceb7e792e46fca83e
 test/extractor-tests/generated/Const/Const_getVisibility.ql de6b2e9d887316e279b45fab7887980ca7d93fd32c2259f3a06de2b6e2957c12 2f135cdbbb84b43d282131edb7eb4df6caba61bf7421881a49d4679f0f44f661
@@ -684,10 +740,9 @@ test/extractor-tests/generated/ContinueExpr/ContinueExpr_getAttr.ql acb261869d3b
 test/extractor-tests/generated/ContinueExpr/ContinueExpr_getLifetime.ql 39dae9872d92fa9b15343c93da545c2b0e15b4f27f2296c200fd4611b68858d5 52a209022e3b83260b4ef5513ffbcc1ca1f7c21bad2c721a0d3698793d2161d2
 test/extractor-tests/generated/DynTraitTypeRepr/DynTraitTypeRepr.ql 513d64b564f359e1022ae6f3d6d4a8ad637f595f01f29a6c2a167d1c2e8f1f99 0c7a7af6ee1005126b9ab77b2a7732821f85f1d2d426312c98206cbbedc19bb2
 test/extractor-tests/generated/DynTraitTypeRepr/DynTraitTypeRepr_getTypeBoundList.ql b20720ff0b147d55cea6f2de44d5bf297e79991eaf103938ccd7ab9d129e9656 eb8c9db2581cea00c29d7772de0b0a125be02c37092217a419f1a2b6a9711a6c
-test/extractor-tests/generated/Enum/Enum.ql ed518d828d8e2e4790849284de1d0d5e728dbc2fe5e9f187e8ebfa2d503efd5a 7092b963eb133371e1cbc09d45f8c2308d7093523140b351d67073a8d258643e
+test/extractor-tests/generated/Enum/Enum.ql 769fb60d06933083a35aa58cb712c580d3dade8b503b7d3bea635e7004f044bc 5ef6388b8e1592f35d21cf1cfbec233ae0fde3c6d6db45733cc09eea4b6c7a5d
 test/extractor-tests/generated/Enum/Enum_getAttr.ql 8109ef2495f4a154e3bb408d549a16c6085e28de3aa9b40b51043af3d007afa7 868cf275a582266ffa8da556d99247bc8af0fdf3b43026c49e250cf0cac64687
-test/extractor-tests/generated/Enum/Enum_getCrateOrigin.ql 76d32838b7800ed8e5cab895c9dbea76129f96afab949598bebec2b0cb34b7ff 226d099377c9d499cc614b45aa7e26756124d82f07b797863ad2ac6a6b2f5acb
-test/extractor-tests/generated/Enum/Enum_getExtendedCanonicalPath.ql 001bb634adc4b20afb241bff41194bc91ba8544d1edd55958a01975e2ac428e1 c7c3fe3dc22a1887981a895a1e5262b1d0ad18f5052c67aa73094586de5212f6
+test/extractor-tests/generated/Enum/Enum_getCanonicalPath.ql 1fc1c7a5049a9c348f9c93fa40e17da84406e9155db69892303ddab38cd05447 389dfb9ec6e72ca100cd9d375abb0a571f7c9ebdb3581b703b7f342f11e9f439
 test/extractor-tests/generated/Enum/Enum_getGenericParamList.ql 2a858a07195a4b26b8c92e28519995bd6eba64889bddd126e161038f4a8d78e0 db188f238db915c67b084bc85aa0784c6a20b97b5a5f1966b3530c4c945b5527
 test/extractor-tests/generated/Enum/Enum_getName.ql 32a8638534f37bfd416a6906114a3bcaf985af118a165b78f2c8fffd9f1841b8 c9ca8030622932dd6ceab7d41e05f86b923f77067b457fb7ec196fe4f4155397
 test/extractor-tests/generated/Enum/Enum_getVariantList.ql eb30e972b93770be1b64eb387814b99b3901e8884dd74701c5478574242f5269 43e2f53c339f27e71954a96e218f6fc8a631b827457f718693eb2c79737b6cb0
@@ -695,16 +750,14 @@ test/extractor-tests/generated/Enum/Enum_getVisibility.ql 7fdae1b147d3d2ed41e055
 test/extractor-tests/generated/Enum/Enum_getWhereClause.ql 00be944242a2056cd760a59a04d7a4f95910c122fe8ea6eca3efe44be1386b0c 70107b11fb72ed722afa9464acc4a90916822410d6b8bf3b670f6388a193d27d
 test/extractor-tests/generated/ExprStmt/ExprStmt.ql 811d3c75a93d081002ecf03f4e299c248f708e3c2708fca9e17b36708da620e5 a4477e67931ba90fd948a7ef778b18b50c8492bae32689356899e7104a6d6794
 test/extractor-tests/generated/ExprStmt/ExprStmt_getExpr.ql e269bb222317afe1470eee1be822d305fc37c65bca2999da8d24a86fa9337036 088369d6c5b072192290c34c1828b1068aeedaabdae131594ca529bbb1630548
-test/extractor-tests/generated/ExternBlock/ExternBlock.ql 45233abdf39caefd2d1d236990a5fbf06eb0b547d892f1ad3e82b8e3c215bc79 df30e0370ed20bef3b2c5bed6e8c27b27663716e7c9e14e85acb6e33a43f4edc
+test/extractor-tests/generated/ExternBlock/ExternBlock.ql 34d345942519d616704acde4481bf8d19d1d5524abd1ca341c6117b7f6e639f8 21c6093c9a50543f14372cda1bd772eda500cbb1a75c1a0cf0f4449db101c0b6
 test/extractor-tests/generated/ExternBlock/ExternBlock_getAbi.ql 9b7c7263fcbc84e07361f5b419026a525f781836ede051412b22fb4ddb5d0c6a c3755faa7ffb69ad7d3b4c5d6c7b4d378beca2fa349ea072e3bef4401e18ec99
 test/extractor-tests/generated/ExternBlock/ExternBlock_getAttr.ql 78ed6a2d31ccab67b02da4792e9d2c7c7084a9f20eb065d83f64cd1c0a603d1b e548d4fa8a3dc1ca4b7d7b893897537237a01242c187ac738493b9f5c4700521
-test/extractor-tests/generated/ExternBlock/ExternBlock_getCrateOrigin.ql 5a2e0b546e17a998156f48f62e711c8a7b920d352516de3518dfcd0dfedde82d 1d11b8a790c943ef215784907ff2e367b13737a5d1c24ad0d869794114deaa32
-test/extractor-tests/generated/ExternBlock/ExternBlock_getExtendedCanonicalPath.ql 40d6ee4bcb77c2669e07cf8070cc1aadfca22a638412c8fcf35ff892f5393b0c e9782a3b580e076800a1ad013c8f43cdda5c08fee30947599c0c38c2638820d6
+test/extractor-tests/generated/ExternBlock/ExternBlock_getCanonicalPath.ql c8a6b799fb2b5fb7f14538336d400f18ed5b9450eead27477142a3ae5c632c61 59cfb18e8cf2393e964f96d0b97ca858f4c3e9d8505518f55eb647ea6046a05f
 test/extractor-tests/generated/ExternBlock/ExternBlock_getExternItemList.ql 2c2b29bdfdc3b27173c068cbaab9946b42053aa14cf371236b4b60ff2e723370 dfc20fc8ef81cdce6f0badd664ef3914d6d49082eb942b1da3f45239b4351e2f
-test/extractor-tests/generated/ExternCrate/ExternCrate.ql c4313ed4790d6c085f47d6c14b11bfa67f7758a1f160758a385bcfcd37284151 9a761086cd80a6fdb7a41f2f6887e1c0b8b3aa19ada0b1dcc74a57646338ecc9
+test/extractor-tests/generated/ExternCrate/ExternCrate.ql c73c0c131023864ce3cd6d42476de61c906422728004e2cabeccbc6d11836118 4b94939837f7e3aaac6cb1945a3dd35f6efdcc2583480733170411d6133d0260
 test/extractor-tests/generated/ExternCrate/ExternCrate_getAttr.ql cbe8efdfdbe5d46b4cd28d0e9d3bffcf08f0f9a093acf12314c15b692a9e502e 67fe03af83e4460725f371920277186c13cf1ed35629bce4ed9e23dd3d986b95
-test/extractor-tests/generated/ExternCrate/ExternCrate_getCrateOrigin.ql c0bf9ba36beb93dc27cd1c688f18b606f961b687fd7a7afd4b3fc7328373dcfb 312da595252812bd311aecb356dd80f2f7dc5ecf77bc956e6478bbe96ec72fd9
-test/extractor-tests/generated/ExternCrate/ExternCrate_getExtendedCanonicalPath.ql 88e16e2bbef466cec43ace25716e354408b5289f9054eaafe38abafd9df327e3 83a69487e16d59492d44d8c02f0baf7898c88ed5fcf67c73ed89d80f00c69fe8
+test/extractor-tests/generated/ExternCrate/ExternCrate_getCanonicalPath.ql c4c0346e43710986270b26be5739f46f52326740563bb8092b6e8c9fa2098b3a 85cc440df53bb13fb93a59d0aa70f92e8f072935294485967a338c73220cc53e
 test/extractor-tests/generated/ExternCrate/ExternCrate_getNameRef.ql 4bbc210ed3114f355a36768fc8173dfb65bd683bdf47491a30890cf110a6fb2c cd9c1b52dd350337e946fb43243de1504f0ae44d81668dab3629f2b7c2651572
 test/extractor-tests/generated/ExternCrate/ExternCrate_getRename.ql 52007ef7745e7ceb394de73212c5566300eb7962d1de669136633aea0263afb2 da98779b9e82a1b985c1b1310f0d43c784e5e66716a791ac0f2a78a10702f34b
 test/extractor-tests/generated/ExternCrate/ExternCrate_getVisibility.ql d2c13d0c19a5ef81ca776f03a7259e743adbfa66ef440f7d402cd97391ecdfc4 c678f6ac0a075c1e0adc3768a344dbeebcf0d13e30878546094777e3fcdf92bd
@@ -741,12 +794,11 @@ test/extractor-tests/generated/FormatArgsExpr/FormatArgument.ql 7a7ee3a3322b4af8
 test/extractor-tests/generated/FormatArgsExpr/FormatArgument_getVariable.ql 7bd4ec3dde2ef0463585794101e6cc426c368b0e4ab95fbb1f24f8f0a76cf471 e7b01e8b21df5b22c51643e2c909c6fc4ca96fda41b3290c907ba228abe8669b
 test/extractor-tests/generated/FormatArgsExpr/FormatTemplateVariableAccess.ql 2793ba1ff52182dab992d82d3767a000928f6b2fbfdb621349cafc183f0d2480 c3777d03214f7feb9020de3ce45af6556129e39e9b30d083de605b70ab9a0a12
 test/extractor-tests/generated/FormatArgsExpr/Format_getArgument.ql 26d592398a17795427b5b6b51ff4a013ee15c31443e732a000baca5f2e65acca 7940a864b84b89e84d7fb186599cb8b6bcbead7141c592b8ab0c59fcd380d5fb
-test/extractor-tests/generated/Function/Function.ql c1c2a9b68c35f839ccd2b5e62e87d1acd94dcc2a3dc4c307c269b84b2a0806e6 1c446f19d2f81dd139aa5a1578d1b165e13bddbaeab8cfee8f0430bced3a99ab
+test/extractor-tests/generated/Function/Function.ql fdbcd3e9db44205c511a7f953d15b4cb859379fea1af1dc1687124bd8f11ba53 cd2ed427589a2c0ff4c07112f8b5a12d348927e43e4e1c459746f9b0e345314d
 test/extractor-tests/generated/Function/Function_getAbi.ql e5c9c97de036ddd51cae5d99d41847c35c6b2eabbbd145f4467cb501edc606d8 0b81511528bd0ef9e63b19edfc3cb638d8af43eb87d018fad69d6ef8f8221454
 test/extractor-tests/generated/Function/Function_getAttr.ql 44067ee11bdec8e91774ff10de0704a8c5c1b60816d587378e86bf3d82e1f660 b4bebf9441bda1f2d1e34e9261e07a7468cbabf53cf8047384f3c8b11869f04e
 test/extractor-tests/generated/Function/Function_getBody.ql cf2716a751e309deba703ee4da70e607aae767c1961d3c0ac5b6728f7791f608 3beaf4032924720cb881ef6618a3dd22316f88635c86cbc1be60e3bdad173e21
-test/extractor-tests/generated/Function/Function_getCrateOrigin.ql acec761c56b386600443411cabb438d7a88f3a5e221942b31a2bf949e77c14b4 ff2387acb13eebfad614b808278f057a702ef4a844386680b8767f9bb4438461
-test/extractor-tests/generated/Function/Function_getExtendedCanonicalPath.ql 0bcdca25bb92424007cea950409d73ba681e3ffbea53e0508f1d630fccfa8bed ff28c3349f5fc007d5f144e549579bd04870973c0fabef4198edce0fba0ef421
+test/extractor-tests/generated/Function/Function_getCanonicalPath.ql 22775208d059fb634903123a4b98e413c9493c507d5095236bfe17639863cf96 a76b74443954bf2395c242374d0ceee531f18890c18ef79f31db9b73229d477f
 test/extractor-tests/generated/Function/Function_getGenericParamList.ql 0b255791c153b7cb03a64f1b9ab5beccc832984251f37516e1d06ce311e71c2b d200f90d4dd6f8dfd22ce49203423715d5bef27436c56ee553097c668e71c5a1
 test/extractor-tests/generated/Function/Function_getName.ql 3d9e0518075d161213485389efe0adf8a9e6352dd1c6233ef0403a9abbcc7ed1 841e644ecefff7e9a82f458bcf14d9976d6a6dbe9191755ead88374d7c086375
 test/extractor-tests/generated/Function/Function_getParamList.ql f888802ab00defb58de59cc39d1e0518e3884db7eaf845f39dfa55befdda58b2 ba0d1a07676f1c987b820a3d126a563ecf9a3d53ac1115b87a5af487a8a03c3e
@@ -766,11 +818,10 @@ test/extractor-tests/generated/IfExpr/IfExpr_getAttr.ql f5872cdbb21683bed689e753
 test/extractor-tests/generated/IfExpr/IfExpr_getCondition.ql 5bab301a1d53fe6ee599edfb17f9c7edb2410ec6ea7108b3f4a5f0a8d14316e3 355183b52cca9dc81591a09891dab799150370fff2034ddcbf7b1e4a7cb43482
 test/extractor-tests/generated/IfExpr/IfExpr_getElse.ql 8674cedf42fb7be513fdf6b9c3988308453ae3baf8051649832e7767b366c12f e064e5f0b8e394b080a05a7bccd57277a229c1f985aa4df37daea26aeade4603
 test/extractor-tests/generated/IfExpr/IfExpr_getThen.ql 0989ddab2c231c0ee122ae805ffa0d3f0697fb7b6d9e53ee6d32b9140d4b0421 81028f9cd6b417c63091d46a8b85c3b32b1c77eea885f3f93ae12c99685bfe0a
-test/extractor-tests/generated/Impl/Impl.ql c473ab1d919fc56b641684b9eb7ba0e65defe554e1bb2fa603b8246a896aa574 16f2f7d8456aee81b395bf8e44fcf0562cfa44294fa03e4f85f3b06f5ff1c57f
+test/extractor-tests/generated/Impl/Impl.ql 0a229c7538deafa304dd14f2ab2610167e8958551ea7218e6112151ca81c50a2 330960df7fae2ed08b1527c6a4424a22e413b340c17a25db4471188a14ed8662
 test/extractor-tests/generated/Impl/Impl_getAssocItemList.ql cf875361c53c081ac967482fd3af8daf735b0bc22f21dcf0936fcf70500a001a 0ad723839fa26d30fa1cd2badd01f9453977eba81add7f0f0a0fcb3adb76b87e
 test/extractor-tests/generated/Impl/Impl_getAttr.ql 018bdf6d9a9724d4f497d249de7cecd8bda0ac2340bde64b9b3d7c57482e715b cd065899d92aa35aca5d53ef64eadf7bb195d9a4e8ed632378a4e8c550b850cd
-test/extractor-tests/generated/Impl/Impl_getCrateOrigin.ql 494d5524ef7bac1286b8a465e833e98409c13f3f8155edab21d72424944f2ed9 b238ef992fce97699b14a5c45d386a2711287fd88fa44d43d18c0cdfd81ed72c
-test/extractor-tests/generated/Impl/Impl_getExtendedCanonicalPath.ql 3ab82fd7831d22c7ec125908abf9238a9e8562087d783c1c12c108b449c31c83 320afd5dd1cea9017dbc25cc31ebe1588d242e273d27207a5ad2578eee638f7e
+test/extractor-tests/generated/Impl/Impl_getCanonicalPath.ql ab036cae598c5c50cdbc3df81a4f3c579dbe642d160741e4ad65eb12f256f334 f8f2eb65a3cefc528d5baf92b0728c3850d1e72b4679800748cc33d3985bd842
 test/extractor-tests/generated/Impl/Impl_getGenericParamList.ql 88d5cd8fd03cb4cc2887393ee38b2e2315eeef8c4db40a9bd94cf86b95935bdd 9c72828669ccf8f7ca39851bc36a0c426325a91fc428b49681e4bb680d6547a9
 test/extractor-tests/generated/Impl/Impl_getSelfTy.ql 2962d540a174b38815d150cdd9053796251de4843b7276d051191c6a6c8ecad4 b7156cec08bd6231f7b8f621e823da0642a0eb036b05476222f259101d9d37c0
 test/extractor-tests/generated/Impl/Impl_getTrait.ql 3319d2649b4a7f3c501c8e16a1a3e5d74057c94c02772d33f19b4030daf934d2 3acca9d040c3f1d90ed26b159dac71625bea689221e180c856a75c2bab95d286
@@ -817,19 +868,17 @@ test/extractor-tests/generated/LoopExpr/LoopExpr.ql 37b320acefa3734331f87414de27
 test/extractor-tests/generated/LoopExpr/LoopExpr_getAttr.ql d557c1a34ae8762b32702d6b50e79c25bc506275c33a896b6b94bbbe73d04c49 34846c9eefa0219f4a16e28b518b2afa23f372d0aa03b08d042c5a35375e0cd6
 test/extractor-tests/generated/LoopExpr/LoopExpr_getLabel.ql 0b77b9d9fb5903d37bce5a2c0d6b276e6269da56fcb37b83cd931872fb88490f c7f09c526e59dcadec13ec9719980d68b8619d630caab2c26b8368b06c1f2cc0
 test/extractor-tests/generated/LoopExpr/LoopExpr_getLoopBody.ql 0267f54077640f3dfeb38524577e4a1229115eeb1c839398d0c5f460c1d65129 96ec876635b8c561f7add19e57574444f630eae3df9ab9bc33ac180e61f3a7b8
-test/extractor-tests/generated/MacroCall/MacroCall.ql f41552ce4c8132db854132e445aa0c8df514bfd375aa71cc9ed0ae838b7df9f1 442ecbe1481084bb072c6f8cf0eb595b7ad371587e8708610a10f2cc718535f7
+test/extractor-tests/generated/MacroCall/MacroCall.ql 0616bbb858e7967ffcfe1cc185339237c2b766f8c1448f1691e7ab754f0bf045 dc2d92da239fec038106a1f72b6b5cd38575e265009a1e52d13dd19ac945fd8b
 test/extractor-tests/generated/MacroCall/MacroCall_getAttr.ql c22a2a29d705e85b03a6586d1eda1a2f4f99f95f7dfeb4e6908ec3188b5ad0ad 9b8d9dcc2116a123c15c520a880efab73ade20e08197c64bc3ed0c50902c4672
-test/extractor-tests/generated/MacroCall/MacroCall_getCrateOrigin.ql 3030e87de6f773d510882ee4469146f6008898e23a4a4ccabcbaa7da1a4e765e a10fe67315eda1c59d726d538ead34f35ccffc3e121eeda74c286d49a4ce4f54
+test/extractor-tests/generated/MacroCall/MacroCall_getCanonicalPath.ql e11be6799451e1833b27610c7d086a606fa954bacacbf05c65de88bcecef0e11 c81f43be23035953a62bdc685e2862266b43859855c4145a5bd585d984737ae5
 test/extractor-tests/generated/MacroCall/MacroCall_getExpanded.ql 757c4a4c32888e4604044c798a3180aa6d4f73381eec9bc28ba9dc71ffcbd03a 27d5edaa2c1096a24c86744aaad0f006da20d5caa28ccfd8528e7c98aa1bead1
-test/extractor-tests/generated/MacroCall/MacroCall_getExtendedCanonicalPath.ql 553b810f611014ae04d76663d1393c93687df8b96bda325bd71e264e950a8be9 a0e80c3dac6a0e48c635e9f25926b6a97adabd4b3c0e3cfb6766ae160bcb4ee7
 test/extractor-tests/generated/MacroCall/MacroCall_getPath.ql 160edc6a001a2d946da6049ffb21a84b9a3756e85f9a2fb0a4d85058124b399a 1e25dd600f19ef89a99f328f86603bce12190220168387c5a88bfb9926da56d9
 test/extractor-tests/generated/MacroCall/MacroCall_getTokenTree.ql 1cbf6b1ac7fa0910ff299b939743153fc00ad7e28a9a70c69a8297c6841e8238 570380c0dc4b20fe25c0499378569720a6da14bdb058e73d757e174bdd62d0c0
-test/extractor-tests/generated/MacroDef/MacroDef.ql b8186c22beb7f818a30fe80f36d2e4207887445863e4deeae88bd03c24863dbb 71bebfb1b57b56ea479bc6edd714a4f01bfce2fa8e12fb9eb1481f9dffa4515e
+test/extractor-tests/generated/MacroDef/MacroDef.ql 1b7b02abba35412523fd1896f093d7e09f9cdaa460850d26d18c6009b7b3b27d 68f7833347979f7ac773d144f120aaf7e10933f603fdd3fe2e1cffeaa19a87df
 test/extractor-tests/generated/MacroDef/MacroDef_getArgs.ql 61f11d6ba6ea3bd42708c4dc172be4016277c015d3560025d776e8fef447270f 331541eff1d8a835a9ecc6306f3adf234cbff96ea74b0638e482e03f3e336fd1
 test/extractor-tests/generated/MacroDef/MacroDef_getAttr.ql 0a30875f7b02351a4facf454273fb124aa40c6ef8a47dfe5210072a226b03656 8e97307aef71bf93b28f787050bfaa50fe95edf6c3f5418acd07c1de64e62cc1
 test/extractor-tests/generated/MacroDef/MacroDef_getBody.ql 7b350f48e6f208d9fa4725919efd439baf5e9ec4563ba9be261b7a17dacc451b 33f99a707bb89705c92195a5f86055d1f6019bcd33aafcc1942358a6ed413661
-test/extractor-tests/generated/MacroDef/MacroDef_getCrateOrigin.ql 6c46366798df82ed96b8fb1efeb46bd84c2660f226ff2359af0041d5cdf004ba 8ab22599ef784dcad778d86828318699c2230c8927ae98ab0c60ac4639d6d1b5
-test/extractor-tests/generated/MacroDef/MacroDef_getExtendedCanonicalPath.ql d09b262b8e5558078506ec370255a63c861ca0c41ab9af3eb4f987325dadd90c cd466062c59b6a8ea2a05ddac1bf5b6d04165755f4773867774215ec5e79afa3
+test/extractor-tests/generated/MacroDef/MacroDef_getCanonicalPath.ql 73617ab1d9f6705a613b6eb56b8eec819aee464b233c1c915789d411bcd447a1 4a2a502b35638a776469b246dcd1638a4cd3e77478565703ccbc7b6dc36b8f12
 test/extractor-tests/generated/MacroDef/MacroDef_getName.ql 6bc8a17804f23782e98f7baf70a0a87256a639c11f92e3c80940021319868847 726f9d8249b2ca6789d37bb4248bf5dd044acc9add5c25ed62607502c8af65aa
 test/extractor-tests/generated/MacroDef/MacroDef_getVisibility.ql d858ccaab381432c529bf4a621afc82ea5e4b810b463f2b1f551de79908e14e7 83a85c4f90417ab44570a862642d8f8fc9208e62ba20ca69b32d39a3190381aa
 test/extractor-tests/generated/MacroExpr/MacroExpr.ql 69445cf24f5bec5c3f11f0ebf13604891bb2c0dffe715612628e5572587c7a6c 5434db79d94e437c86126d9cf20bf1e86e5537f462a57b9bf6b22a2caa95cc40
@@ -838,10 +887,9 @@ test/extractor-tests/generated/MacroItems/MacroItems.ql 876b5d2a4ce7dcb599e02208
 test/extractor-tests/generated/MacroItems/MacroItems_getItem.ql 53fc2db35a23b9aca6ee327d2a51202d23ddf482e6bdd92c5399b7f3a73959b1 63051c8b7a7bfbe9cc640f775e753c9a82f1eb8472989f7d3c8af94fdf26c7a0
 test/extractor-tests/generated/MacroPat/MacroPat.ql d9ec72d4d6a7342ee2d9aa7e90227faa31792ca5842fe948d7fdf22597a123b7 74b0f21ef2bb6c13aae74dba1eea97451755110909a083360e2c56cfbc76fd91
 test/extractor-tests/generated/MacroPat/MacroPat_getMacroCall.ql 398996f0d0f2aa6d3b58d80b26c7d1185b5094d455c6c5c7f075f6d414150aa6 b4662e57cac36ed0e692201f53ba46c3d0826bba99c5cc6dfcb302b44dd2154b
-test/extractor-tests/generated/MacroRules/MacroRules.ql e8a243a1aa368d44c963d81b4459aa6eba7caf514d4865af5007cc33fe53dde4 9e9114cb808239e3bb15403cf5712f8dbaf4e2719e74efddbb800ec0be19f06a
+test/extractor-tests/generated/MacroRules/MacroRules.ql bab0c425f34c95341dc5e0cc724528ba3339528fd291b6ab1a9b2b2e1b807904 91c3bec6bbbeeba58dbe8cff226fd8347866fcc929e0e592b88d1c9051240327
 test/extractor-tests/generated/MacroRules/MacroRules_getAttr.ql 7de501c724e3465520cdc870c357911e7e7fce147f6fb5ed30ad37f21cf7d932 0d7754b89bcad6c012a0b43ee4e48e64dd20b608b3a7aeb4042f95eec50bb6e6
-test/extractor-tests/generated/MacroRules/MacroRules_getCrateOrigin.ql fccedeee10ef85be3c26f6360b867e81d4ebce3e7f9cf90ccb641c5a14e73e7d 28c38a03a7597a9f56032077102e7a19378b0f3f3a6804e6c234526d0a441997
-test/extractor-tests/generated/MacroRules/MacroRules_getExtendedCanonicalPath.ql a0098b1d945df46e546e748c2297444aaccd04a4d543ba3d94424e7f33be6d26 3bab748c7f5bbe486f30e1a1c422a421ab622f401f4f865afb003915ae47be83
+test/extractor-tests/generated/MacroRules/MacroRules_getCanonicalPath.ql 18798d1de82776729e42e2044987d1b9d116cd5f2e08ebafa24f92ca833507fd 556b10708e758c534e84d6408cc68c50b715c5d452cab7adb11dffed5450f208
 test/extractor-tests/generated/MacroRules/MacroRules_getName.ql 591606e3accae8b8fb49e1218c4867a42724ac209cf99786db0e5d7ea0bf55d5 d2936ef5aa4bbf024372516dde3de578990aafb2b8675bbbf0f72e8b54eb82a8
 test/extractor-tests/generated/MacroRules/MacroRules_getTokenTree.ql 7598d33c3d86f9ad8629219b90667b2b65e3a1e18c6b0887291df9455a319cab 69d90446743e78e851145683c17677497fe42ed02f61f2b2974e216dc6e05b01
 test/extractor-tests/generated/MacroRules/MacroRules_getVisibility.ql 5306cc85f470d21ebcbe6e98436334b0bf5ba819a0ae186569ba7e88c31636c6 fcbf5c54e5a904767a6f4d37d853072aa0040738e622c49c9a02dec8739d6587
@@ -868,18 +916,16 @@ test/extractor-tests/generated/Meta/Meta.ql 16f163f00ba2bbaa0a8c6f3f6710c860a8f6
 test/extractor-tests/generated/Meta/Meta_getExpr.ql ec9ec61f5be7d65c32775fb5c068daea04f9db7d875293ed99cc1b2481db041f 77a0c52f1cb6ddc8fdb294d637f9eda1b7301ffa3067f0fca6272d894f57d3ee
 test/extractor-tests/generated/Meta/Meta_getPath.ql aa9d4145a4e613c51b6e4637d57e3b7d0f66e0bb88f4ce959d598870814c06bb 2087e00686d502c0e2e89c88eae0fb354463576a9ae4101320981d3fd79b9078
 test/extractor-tests/generated/Meta/Meta_getTokenTree.ql 1051c27ffd0d9a20436d684fde529b9ff55abe30d50e1d575b0318951e75bd34 983975672d928fb907676628384c949731da9807bf0c781bb7ec749d25733d2d
-test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql 0149a2d174c72a530b39a5878e204cb6db7632935a5ceaf20e2b2363b67dfdf6 8284d9133c21136f89a04105c280efe736a782035235c6abc081f3d9a2616447
+test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql 4e1ce970974bc31ea82568700eb1c2bd79f0a98d7589b92e3ff1c236db52aea0 62d413e029aecfa1ed976722f0ead0f1887b39c408b5c44a6b53e81d4715dcdd
 test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getArgList.ql 180e0b1715f5cd2be0de01bff3d3a45594b495b8250748d40ff7108d6c85923d bdadcdbecca5891287a47b6dd6b2fda62e07457718aef39212503ab63bc17783
 test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getAttr.ql 2ce876a04a159efce83b863dffc47fbb714b95daea2b91fa6fbb623d28eed9ec 7bca1cd0e8fbceec0e640afb6800e1780eff5b5b402e71b9b169c0ba26966f96
 test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getGenericArgList.ql 655db9a0501b1ef20d604cc4cd9d708371781291443e8dec97b70ec2914601d2 2fc7df0eca22dcef2f9f5c86d37ee43452d372a4c0f9f4da0194828c82ba93e0
 test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getNameRef.ql 9a4829a174388e818f0c63ee6b8bdf1b68beaab48f51734ec6cc14635d24001c f57c9cdaf5235aad604f60b53ce92e73946d03a085f95ed051a26683967be4ba
 test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getReceiver.ql 77407ac956c897ff7234132de1a825f1af5cfd0b6c1fd3a30f64fe08813d56db d80719e02d19c45bd6534c89ec7255652655f5680199854a0a6552b7c7793249
-test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCrateOrigin.ql c22504665900715e8a32dd47627111e8cef4ed2646f74a8886dead15fbc85bb5 d92462cf3cb40dcd383bcaffc67d9a43e840494df9d7491339cbd09a0a73427b
-test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedPath.ql 9e7bbb7ed60db49b45c3bdf8e01ec58de751889fc394f59ac33f9d6e98200aa1 c055d877e2ff0edc78cce6dd79c78b2881e7940889729cbb5c12e7029ddeb5a3
-test/extractor-tests/generated/Module/Module.ql 4bc4d74921a5af94b124a5010cdf6908cdc9ecf26124e354155fba781009071f acca26579b087ce1fc674703c4d95d8d353075d3021c464d2f3fc06891716774
+test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCanonicalPath.ql 7c1692b433e4580a3eadfa75b0881d931bfa398291aebfbf6acbb4fc49b7f1c2 554275f8d13e95c35f5c529f3c43e7d10f7fdeb524c47dba6a42229922736734
+test/extractor-tests/generated/Module/Module.ql 646ceef7347b6d8f7ae7b9360aabcfec6ccfc3cf612351ce246a35414b7ac743 6e733c1d3d9b9d84e2b12c84722c884b03e6c7941563f5e22cdb1a4f56e0b36f
 test/extractor-tests/generated/Module/Module_getAttr.ql b97ae3f5175a358bf02c47ec154f7c2a0bd7ca54d0561517008d59344736d5cd f199116633c183826afa9ab8e409c3bf118d8e626647dbc617ae0d40d42e5d25
-test/extractor-tests/generated/Module/Module_getCrateOrigin.ql ff479546bf8fe8ef3da60c9c95b7e8e523c415be61839b2fff5f44c146c4e7df b14d3c0577bd6d6e3b6e5f4b93448cdccde424e21327a2e0213715b16c064a52
-test/extractor-tests/generated/Module/Module_getExtendedCanonicalPath.ql 55c5b633d05ddbe47d324535a337d5dfed5913ab23cdb826424ddd22009a2a53 ab9e11e334e99be0d4c8d2bd0580657211d05feeeb322fbb5400f07264219497
+test/extractor-tests/generated/Module/Module_getCanonicalPath.ql d700ee897697745c08fcf6cfbaf979b621f51bf2e221a4a99b59518f9bf6105f 947338c5590db48733a331e870e58a9eb78e0dca75e463dccff162a437483e78
 test/extractor-tests/generated/Module/Module_getItemList.ql 59b49af9788e9d8b5bceaeffe3c3d203038abd987880a720669117ac3db35388 9550939a0e07b11892b38ca03a0ce305d0e924c28d27f25c9acc47a819088969
 test/extractor-tests/generated/Module/Module_getName.ql 7945dc007146c650cf4f5ac6e312bbd9c8b023246ff77f033a9410da29774ace 9de11a1806487d123376c6a267a332d72cd81e7d6e4baa48669e0bb28b7e352e
 test/extractor-tests/generated/Module/Module_getVisibility.ql bdce43e97b99226f55c84547a84d99b44f5d1eac757d49bcc06d732e0fb0b5a8 a482c18851286fb14ec6f709dc7f3280a62de8c3d59c49ba29d07bd24cf416cd
@@ -909,15 +955,13 @@ test/extractor-tests/generated/ParenPat/ParenPat_getPat.ql 96f3db0ec4e71fd870619
 test/extractor-tests/generated/ParenTypeRepr/ParenTypeRepr.ql a96bb8b51d8c0c466afc1c076834fa16edf7e67fffe2f641799850dee43099a2 0e6c375e621b7a7756d39e8edd78b671e53d1aac757ac54a26747fe5259c5394
 test/extractor-tests/generated/ParenTypeRepr/ParenTypeRepr_getTypeRepr.ql 64fe4ea708bc489ba64ed845f63cfbcd57c1179c57d95be309db37eac2f5eb71 0f4cbbfdf39d89830b5249cabf26d834fc2310b8a9579c19383c90cb4333afb7
 test/extractor-tests/generated/Path/Path.ql 2bdcd99b3b5ffc83ac47d8cc27a4561d616bcf06844f0c452c699cd10ee640ca 5a7d7ffb8b0c04d6a8cbb2a953761df8561b796c4372bef1bd55c359b2f19911
-test/extractor-tests/generated/Path/PathExpr.ql 5039fe730998a561f51813a0716e18c7c1d36b6da89936e4cfbdb4ef0e895560 cd3ddf8ab93cd573381807f59cded7fb3206f1dbdff582490be6f23bed2d6f29
+test/extractor-tests/generated/Path/PathExpr.ql 85f1f80a16b18cf888ef60fdc956deb5e02365b8da7f4126993dccc942c07181 654d5bf44100d746a90b8a560ac609811263e36483ce510d40ea253df3c5631b
 test/extractor-tests/generated/Path/PathExpr_getAttr.ql 2ccac48cd91d86670c1d2742de20344135d424e6f0e3dafcc059555046f92d92 9b7b5f5f9e3674fad9b3a5bcd3cabc0dff32a95640da0fce6f4d0eb931f1757d
 test/extractor-tests/generated/Path/PathExpr_getPath.ql e7894071313a74166bdd31d7cd974037fcd5a7f0e92d5eec42833266196eb858 46a06e8a1207e7a0fa175cd4b61068e5fd6c43b5575b88986409f0ac2be64c51
-test/extractor-tests/generated/Path/PathExpr_getResolvedCrateOrigin.ql a68a1f0d865d10c955f7ab1fd7614b517e660553b65fabb9daa8f302adbc2602 c47480d6440ae63be27d8158a35536a8d9051817dec1521cdcab297ddb52e1ae
-test/extractor-tests/generated/Path/PathExpr_getResolvedPath.ql dfa55fe480da0df37670660fc1c54b6c38d47365353bc9d4f662183b33d4e80f 1b18329a7b60805fc073df3149c48f39aa66924d7eefedecbca36a2b170a7fbe
-test/extractor-tests/generated/Path/PathPat.ql 6b9d973009f1b4963c7c83b0f5051eda7a76c8fb4a789217b4a25cbab0cdb274 57f0621dd3657b6f4630d5406816effcc6bc1b03361aa12e118e807e28e9e71b
+test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.ql c6ba7bea708fbd8137767b813c8008fbb367eda1a9a9ab2b35f6cd4ff9915522 029bcde2f10d3e17d9e092dd49be9d6956e51dbfaed78911c70a65dea0b78300
+test/extractor-tests/generated/Path/PathPat.ql 0f0fe27311d61ee005b14b7e685c84b8ce6eaa2d57d848211b63e78d20457bc7 85525db4dc85bdb83bd373fa30473fe9d6a5697e84f5086be8933dd6ad65b2b8
 test/extractor-tests/generated/Path/PathPat_getPath.ql 6c0c71c80a6e631ea7775ec8660b470ff6b264bab14a399606cf113b1fb190fc 8e34cbb4d064db929e94652e1901ec4f26affa71e30e556b7acdff71dd622cbb
-test/extractor-tests/generated/Path/PathPat_getResolvedCrateOrigin.ql f690fd9a8773e7c73b70f2d64ee919fef8eee243c5a315c4a6d2713d43ea0e43 f37817427c36cec14a2e07f99d3a32f37f3f27a8eafdf170749ec2780054729b
-test/extractor-tests/generated/Path/PathPat_getResolvedPath.ql 55df4541a7b0e82198acfcedd7dc99eb564908270e4fb2b032bf05e40fba6fef a5932d884903da901263f88644c8585a45045190d7204f630506c5aece798288
+test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.ql 5fb21b11e054054947f1c7b52b985e90a5ddb0e93915b48af68ae15888960b36 e3cb25aab7053cc2b9fe2966cfa6c43677cdf177f1515efb0634228be8fc076b
 test/extractor-tests/generated/Path/PathSegment.ql be9d62d38b0c7f8b5a8ea86dcb18c62f24930f5931f52e6073414f291d8c0451 31288b7728d45715acf6ab751b833b29473a74d54d9b26f83a73d8c91e3c82da
 test/extractor-tests/generated/Path/PathSegment_getGenericArgList.ql 8f6e67b3e316309f20e21d7e7944accf66b0256b76fa50ee9a714044c6ec8cea 15f10a701fc4d3f9fd6734da90790cdbc8a1ddd57bf52695740acedcb2e6e485
 test/extractor-tests/generated/Path/PathSegment_getNameRef.ql 799d284e2f9267d6bbe67aa7035e525ef347dc74cb3e2180e7b2171b5cb49674 592130bc2358989536abf62e8a261272c851483ede4f19783f7d61ffc1803e4b
@@ -945,11 +989,10 @@ test/extractor-tests/generated/RangePat/RangePat.ql 97314b9a5543a7471d722ae188a6
 test/extractor-tests/generated/RangePat/RangePat_getEnd.ql 723eb5030ec52d3aa3650a3e2de6cc0195a0030630239b972235963320e0d808 2df3b1a6197c3abd43dc743fd09cbf55165e3191f2b49336777594541e5da96a
 test/extractor-tests/generated/RangePat/RangePat_getOperatorName.ql 564216b2342f56dc8c1aed6306f57b6dafb33de9e3ba337a840a8c077ce95933 2a76ec7a59bada29733a1515bc1ea8bedd37429d1694ca63c7a8fbf94098a4c7
 test/extractor-tests/generated/RangePat/RangePat_getStart.ql ad2066efa32fced2dd107031f2a9b9635c3c892e874870a4320522bae9309aa4 b4a8c57a838074e186b823938d1a9372153c193da6c839b5f242ca25c679e83f
-test/extractor-tests/generated/RecordExpr/RecordExpr.ql 220f7f766587dc9df1c6f81a1cda3d19d7d5e92a31c63752061297e1adf96bf0 792bbe4503adcb63f7ac0f11259bb60a8ce05538ba1676f141989a73ff4eb5c0
+test/extractor-tests/generated/RecordExpr/RecordExpr.ql fbdd0032a2b9566b568c9a4e4fe143ce50b4465f9bc3d73fbc2f30c3ede09afc fbf446dcf04705293fa1ba456760f48e6d51989e6ce112694e6d2dd1ec7c2bde
 test/extractor-tests/generated/RecordExpr/RecordExpr_getPath.ql 2eb8f7591f08199d124732d7f2d7dd3e81792a52f8e6c90003aa0609923f8cb0 27e245224d6c9aa20023b418ce8dffff1293b50a0e10938932631fca7c559e78
 test/extractor-tests/generated/RecordExpr/RecordExpr_getRecordExprFieldList.ql 6d3d872eb64ff8cd7317190f9b2627d3fa6a74976e362cfb49e21c6623d63f82 d98b07f932ecb25a427e655017de47f951d3eabc4eedbc6f873571ce8921e9ff
-test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCrateOrigin.ql 87d463c7950407c86783b9ccbcf6daa4f62f5fcb75bc20f1879bde9240281d4d 5659b4fb8b25cd998211aa3edb11188b3c487cabaf7a09989ce6fe0e4f67ba25
-test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedPath.ql 0de885c7efdd257ee44d2c8a2ad91e419d604517471966059ddae321e80597b6 7977fb7a8c954733dbb5cf8378d6103688d16bc4c9b891c68098d0ec224429b4
+test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCanonicalPath.ql 0df6c5d228c02ad9d676829d3a86e7c099a4a1e506e1bf016bf6d4da40dc408b 50fea626f0969ea9107c59a38339926a92b5d3170e46293d1f737a4eaeb01d68
 test/extractor-tests/generated/RecordExprField/RecordExprField.ql 62ee00e478fcf07421b5989943a487ecc0c99cf50ec87f05aabe89dfb03f2a32 ad7c6ce362032e18fc9950b885c4b7b5c907e6abd2af2d13ecef84eb980027fb
 test/extractor-tests/generated/RecordExprField/RecordExprField_getAttr.ql 789d20f8c0bb0e9567d3d9a0c0266a04841cda0dbdbe10af8c450d5a82bb289e 9036f5b0e7ddf301012f52f3919804382421061366d2a4f3a016e9783befec6d
 test/extractor-tests/generated/RecordExprField/RecordExprField_getExpr.ql 7dcb5cf0d04bcd62b655fa0626535526cdaa0f891845f4b22cb50fcf1ae3e511 a177db76e4e9583438fad9bfb1300fed9e812c1046c44dccd307bf3a46603a69
@@ -965,11 +1008,10 @@ test/extractor-tests/generated/RecordField/RecordField_getTypeRepr.ql f61cfcd0c6
 test/extractor-tests/generated/RecordField/RecordField_getVisibility.ql cc45e9bb9418d15cef07a1827358c3f18a8737324c8e6852591a2da70df89360 45557497fc165a212fffda71dedabc8159a4f72323430df732698a18922b366c
 test/extractor-tests/generated/RecordFieldList/RecordFieldList.ql 586bccfa550243177d9fdfd6900a473f51a76ed360b537f19cb300330d5dad5b a063373dfdbf06b68c69694ea4ae72a26b906c910f9095894c09e72f8fb52819
 test/extractor-tests/generated/RecordFieldList/RecordFieldList_getField.ql 2eb92ef8528204f3f105c19a36cdc06b3b6d20242463ff2ed1fb81c544812a71 d69091899e7157099f117e14fe60cd3705cfda45f28f6a6a2b7234a4a9c1e664
-test/extractor-tests/generated/RecordPat/RecordPat.ql 24469c2a0902196d49249a37a0b56bf9fe62d1e7af3150813200b25ccb46dfaa 479e58d4fe6db7048e0649fd5a9c1b8ca1ceb8aa52a80dd07a999a07e32b0a3f
+test/extractor-tests/generated/RecordPat/RecordPat.ql c6caf4b6f215de2c3df3b51931be5a05f3432d65995de69807e1578f0f4ce2e5 521e5265e19f6df3132310c8987589ae686be1068b7f4434ffa4a0da82bdb1ea
 test/extractor-tests/generated/RecordPat/RecordPat_getPath.ql 187b8d44de158fc809257e28b2e8fdd246c8eb3c60115d54cd53396a320e372d 74813fd13c6f34927420ed44620743f7c80c537984e0db72c1c5f4b754b40b83
 test/extractor-tests/generated/RecordPat/RecordPat_getRecordPatFieldList.ql 32e45a6f59cdb8edbf7f9326164e225a7f545fabd2dd168b660699954a999fdf 325c9121dc130459426b473691876a0698b51d5cdf4530698a398510ce8e3051
-test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCrateOrigin.ql 61a47db765e0c45797d3f92318fb6dbf07dfe1a2e63704294c58d49cb0894676 86a636746458053278a8ba0be062a9b1cfcad4866e065a8317fa8f033518ecae
-test/extractor-tests/generated/RecordPat/RecordPat_getResolvedPath.ql 0221208e93c4a26e555dd848238b4f5bcabf2ccf3fc38ceb2eef45c39d67b21a 37d80014a21a19e9132ad645a17234e33bb20f2352b450277b8fa919a54b95e9
+test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCanonicalPath.ql c323c91c14aee44659492db28711c238c2e4b2bf5b8b6ab327fff63a5fa935dd 246b72cfa03cdf24b0189b476af748116254160f73b8511416f373826cebabaf
 test/extractor-tests/generated/RecordPatField/RecordPatField.ql 6c51343258e56673d21b7ae73e7de011319ffa2eb65390e697f875bb428d25d1 82c3232db0cb353140618749b1cba5549b0ff43cbbaafb203077e18dbedb2c10
 test/extractor-tests/generated/RecordPatField/RecordPatField_getAttr.ql fb0592f7a1be4fd9c6f36c79dee5a0f6711b0a7820b079f8e95413722ae1aeb7 9dfb0de00ec9c4a23efd38515c63a3567204f2a3ac2634858296f58aa564d170
 test/extractor-tests/generated/RecordPatField/RecordPatField_getNameRef.ql 3380a41d6cecd80681fc955719fa11377c32a5e0be276871f2d0d75ae62d8f0a 44efe89657d3a59fb94962d0fbf52d06571e203863a3d9e9dd47a5135a8ba4d9
@@ -1007,11 +1049,10 @@ test/extractor-tests/generated/SliceTypeRepr/SliceTypeRepr_getTypeRepr.ql a6604f
 test/extractor-tests/generated/SourceFile/SourceFile.ql c30a3c2c82be3114f3857295615e2ec1e59c823f0b65ea3918be85e6b7adb921 6a5bbe96f81861c953eb89f77ea64d580f996dca5950f717dd257a0b795453e6
 test/extractor-tests/generated/SourceFile/SourceFile_getAttr.ql 450404306b3d991b23c60a7bb354631d37925e74dec7cc795452fe3263dc2358 07ffcc91523fd029bd599be28fe2fc909917e22f2b95c4257d3605f54f9d7551
 test/extractor-tests/generated/SourceFile/SourceFile_getItem.ql f17e44bc0c829b2aadcb6d4ab9c687c10dc8f1afbed4e5190404e574d6ab3107 1cf49a37cc32a67fdc00d16b520daf39143e1b27205c1a610e24d2fe1a464b95
-test/extractor-tests/generated/Static/Static.ql b633f189040bc9d0592b77440b5b161b5c69cab97c4f47ef2c3754671fab0fc2 8dba58a18a217b741a7c474bffe0b3ab524cba8e1e4d6ddb22181170d2971fca
+test/extractor-tests/generated/Static/Static.ql f4b8c49c4b3ce9de632307521c04f3bb1df30ada73e6f7aae1dd268912fff507 508769a32d9a2af35217e43ce3c4f0f05cb979a09e2e6f704392a4a4bbc2579c
 test/extractor-tests/generated/Static/Static_getAttr.ql adb0bbf55fb962c0e9d317fd815c09c88793c04f2fb78dfd62c259420c70bc68 d317429171c69c4d5d926c26e97b47f5df87cf0552338f575cd3aeea0e57d2c2
 test/extractor-tests/generated/Static/Static_getBody.ql e735bbd421e22c67db792671f5cb78291c437621fdfd700e5ef13b5b76b3684d 9148dc9d1899cedf817258a30a274e4f2c34659140090ca2afeb1b6f2f21e52f
-test/extractor-tests/generated/Static/Static_getCrateOrigin.ql f24ac3dac6a6e04d3cc58ae11b09749114a89816c28b96bf6be0e96b2e20d37f e4051426c5daa7e73c1a5a9023d6e50a2b46ebf194f45befbe3dd45e64831a55
-test/extractor-tests/generated/Static/Static_getExtendedCanonicalPath.ql 6ec02f7ec9cf4cb174a7cdf87921758a3e798c76171be85939614305d773b6a0 c51567dac069fc67ece0aa018ae6332187aa1145f33489093e4aee049d7cea52
+test/extractor-tests/generated/Static/Static_getCanonicalPath.ql b259ce842d2286f6c36b0a942dd724ef447c886cc2e1aeb51359a933800b959c 2a5a035ca6c6dc2411c929652739630a23042600d32fe7e0f22135a1227f75b4
 test/extractor-tests/generated/Static/Static_getName.ql c7537e166d994b6f961547e8b97ab4328b78cbd038a0eb9afaae42e35f6d9cb4 bb5ae24b85cd7a8340a4ce9e9d56ec3be31558051c82257ccb84289291f38a42
 test/extractor-tests/generated/Static/Static_getTypeRepr.ql 45efcf393a3c6d4eca92416d8d6c88e0d0e85a2bc017da097ae2bbbe8a271a32 374b551e2d58813203df6f475a1701c89508803693e2a4bec7afc86c2d58d60b
 test/extractor-tests/generated/Static/Static_getVisibility.ql 0672b27f16955f7b0223a27c037884338dcf30759b7b8bb3da44e5d533228f90 0e4916f5683963041ef23c724ca8e16acfa370b583d90b76508c87131b9e1c73
@@ -1019,10 +1060,9 @@ test/extractor-tests/generated/StmtList/StmtList.ql 0010df0d5e30f7bed3bd5d916faf
 test/extractor-tests/generated/StmtList/StmtList_getAttr.ql 78d4bf65273498f04238706330b03d0b61dd03b001531f05fcb2230f24ceab64 6e02cee05c0b9f104ddea72b20097034edb76e985188b3f10f079bb03163b830
 test/extractor-tests/generated/StmtList/StmtList_getStatement.ql abbc3bcf98aab395fc851d5cc58c9c8a13fe1bdd531723bec1bc1b8ddbec6614 e302a26079986fa055306a1f641533dfde36c9bc0dd7958d21e2518b59e808c2
 test/extractor-tests/generated/StmtList/StmtList_getTailExpr.ql 578d7c944ef42bdb822fc6ce52fe3d49a0012cf7854cfddbb3d5117133700587 64ea407455a3b4dfbb86202e71a72b5abbff885479367b2834c0dd16d1f9d0ee
-test/extractor-tests/generated/Struct/Struct.ql 14dc5ead6bed88c2c79d9fd3874198f845d8202290b0931b2d2375c0a397c44a 408b07b6bb40ca09f51d2becd94501cc2b95ec52e04ccc2703c2e25d6577b4c6
+test/extractor-tests/generated/Struct/Struct.ql c9ea9f8e309732ba451b88acb7ba9dbc406085a9363b0cae8c59a2f9d80ef804 3ad984a5cdb0a5295daaf8521eaacfe0712a43911a0301ec0230b1010673a0d4
 test/extractor-tests/generated/Struct/Struct_getAttr.ql 028d90ddc5189b82cfc8de20f9e05d98e8a12cc185705481f91dd209f2cb1f87 760780a48c12be4581c1675c46aae054a6198196a55b6b989402cc29b7caf245
-test/extractor-tests/generated/Struct/Struct_getCrateOrigin.ql 289622244a1333277d3b1507c5cea7c7dd29a7905774f974d8c2100cea50b35f d32941a2d08d7830b42c263ee336bf54de5240bfc22082341b4420a20a1886c7
-test/extractor-tests/generated/Struct/Struct_getExtendedCanonicalPath.ql 866a5893bd0869224fb8aadd071fba35b5386183bb476f5de45c9de7ab88c583 267aedc228d69e31ca8e95dcab6bcb1aa30f9ebaea43896a55016b7d68e3c441
+test/extractor-tests/generated/Struct/Struct_getCanonicalPath.ql c3c09ee605cade0f250818db21abce9311c8b0ada4687dc8b0de0275ae3bc3ad 4e64a3fbe2e95ebd50d4f66ad0c2b6ab1ec89795faef9a1efb06995786fd2b7a
 test/extractor-tests/generated/Struct/Struct_getFieldList.ql f45d6d5d953741e52aca67129994b80f6904b2e6b43c519d6d42c29c7b663c42 77a7d07e8462fa608efc58af97ce8f17c5369f9573f9d200191136607cb0e600
 test/extractor-tests/generated/Struct/Struct_getGenericParamList.ql cd72452713004690b77086163541fa319f8ab5faf503bb4a6a20bcaf2f790d38 4d72e891c5fac6e491d9e18b87ecf680dc423787d6b419da8f700fe1a14bc26f
 test/extractor-tests/generated/Struct/Struct_getName.ql 8f1d9da4013307b4d23a1ce5dc76466ecdd7f0010b5148ec2e7dd2883efe3427 411b326d15d56713c2a5e6d22909474c5d33062296518221e36c920927f859fe
@@ -1032,20 +1072,18 @@ test/extractor-tests/generated/TokenTree/TokenTree.ql ba2ef197e0566640b57503579f
 test/extractor-tests/generated/Trait/AssocItemList.ql 0ea572b1350f87cc09ce4dc1794b392cc9ad292abb8439c106a7a1afe166868b 6e7493a3ace65c68b714e31234e149f3fc44941c3b4d125892531102b1060b2f
 test/extractor-tests/generated/Trait/AssocItemList_getAssocItem.ql 8149d905f6fc6caeb51fa1ddec787d0d90f4642687461c7b1a9d4ab93a27d65d 8fb9caad7d88a89dd71e5cc8e17496afbdf33800e58179f424ef482b1b765bb1
 test/extractor-tests/generated/Trait/AssocItemList_getAttr.ql 06526c4a28fd4fdce04ca15fbadc2205b13dcc2d2de24177c370d812e02540e6 79c8ce6e1f8acc1aaca498531e2c1a0e7e2c0f2459d7fc9fe485fd82263c433f
-test/extractor-tests/generated/Trait/Trait.ql e88ff04557cf050a5acb5038537bb4f7a444c85721eaf3e0aa4c10e7e7724c56 e37b9e60fa8cc64ef9e8db1707d2d8c5a62f9804233c939b4aaa39762b9b0a9a
+test/extractor-tests/generated/Trait/Trait.ql 7cb27d07d2293509bbb040902e1d7d917f3a9e4d3bc148efbd21a257cd63627d 44a798b39328f925f6ed2a855c08fd986efe3a24373220d7170685c6e95d993f
 test/extractor-tests/generated/Trait/Trait_getAssocItemList.ql 05e6896f60afabf931a244e42f75ee55e09c749954a751d8895846de3121f58f def1f07d9945e8d9b45a659a285b0eb72b37509d20624c88e0a2d34abf7f0c72
 test/extractor-tests/generated/Trait/Trait_getAttr.ql 9711125fa4fc0212b6357f06d1bc50df50b46168d139b649034296c64d732e21 901b6a9d04055b563f13d8742bd770c76ed1b2ccf9a7236a64de9d6d287fbd52
-test/extractor-tests/generated/Trait/Trait_getCrateOrigin.ql d8433d63bb2c4b3befaaedc9ce862d1d7edcdf8b83b3fb5529262fab93880d20 3779f2678b3e00aac87259ecfe60903bb564aa5dbbc39adc6c98ad70117d8510
-test/extractor-tests/generated/Trait/Trait_getExtendedCanonicalPath.ql a2bd16e84f057ed8cb6aae3e2a117453a6e312705302f544a1496dbdd6fcb3e6 b4d419045430aa7acbc45f8043acf6bdacd8aff7fdda8a96c70ae6c364c9f4d1
+test/extractor-tests/generated/Trait/Trait_getCanonicalPath.ql 2ff57c8006af1e2d2746d83f8500f5fec109548443677dbb2627ff9b9cbcaf82 2f48643287bfe8081930521cc0282b2a27e62bd9c332971ca8dd6b2c007fe05f
 test/extractor-tests/generated/Trait/Trait_getGenericParamList.ql b27ff28e3aff9ec3369bbbcbee40a07a4bd8af40928c8c1cb7dd1e407a88ffee 2b48e2049df18de61ae3026f8ab4c3e9e517f411605328b37a0b71b288826925
 test/extractor-tests/generated/Trait/Trait_getName.ql d4ff3374f9d6068633bd125ede188fcd3f842f739ede214327cd33c3ace37379 3dcf91c303531113b65ea5205e9b6936c5d8b45cd3ddb60cd89ca7e49f0f00c1
 test/extractor-tests/generated/Trait/Trait_getTypeBoundList.ql 8a4eb898424fe476db549207d67ba520999342f708cbb89ee0713e6bbf1c050d 69d01d97d161eef86f24dd0777e510530a4db5b0c31c760a9a3a54f70d6dc144
 test/extractor-tests/generated/Trait/Trait_getVisibility.ql 8f4641558effd13a96c45d902e5726ba5e78fc9f39d3a05b4c72069993c499f4 553cf299e7d60a242cf44f2a68b8349fd8666cc4ccecab5ce200ce44ad244ba9
 test/extractor-tests/generated/Trait/Trait_getWhereClause.ql b34562e7f9ad9003d2ae1f3a9be1b5c141944d3236eae3402a6c73f14652e8ad 509fa3815933737e8996ea2c1540f5d7f3f7de21947b02e10597006967efc9d1
-test/extractor-tests/generated/TraitAlias/TraitAlias.ql 8870048164ba3c3ea8d4c10e5793d860a4ed3ef0890bf32409827321ddde4b72 9a912ebba80977656e74e1d94478c193164684f01371e23f09817231b58007ff
+test/extractor-tests/generated/TraitAlias/TraitAlias.ql 67fe4f72859c5392ad228f3385c347551ea1c246e75cdc5fc232888dbeefb99c 41ee85bcbb6d59ab3ab88f531411ddfcee08cd35eb25f16c3286bd4bcbbb09d8
 test/extractor-tests/generated/TraitAlias/TraitAlias_getAttr.ql 128c24196bfa6204fffd4154ff6acebd2d1924bb366809cdb227f33d89e185c8 56e8329e652567f19ef7d4c4933ee670a27c0afb877a0fab060a0a2031d8133e
-test/extractor-tests/generated/TraitAlias/TraitAlias_getCrateOrigin.ql 303212122021da7f745050c5de76c756461e5c6e8f4b20e26c43aa63d821c2b6 fdbd024cbe13e34265505147c6faffd997e5c222386c3d9e719cd2a385bde51c
-test/extractor-tests/generated/TraitAlias/TraitAlias_getExtendedCanonicalPath.ql 601b6b0e5e7e7f2926626866085d9a4a9e31dc575791e9bd0019befc0e397193 9bd325414edc35364dba570f6eecc48a8e18c4cbff37d32e920859773c586319
+test/extractor-tests/generated/TraitAlias/TraitAlias_getCanonicalPath.ql f8491de4aa92f5d5f0ad4b91625f60a8d53eb3a02893b7f468dcf1e9065492a2 d2fad385018764ad9f962e1ec8e98b20286d4c2188ba975e5ec96b24cf747a6e
 test/extractor-tests/generated/TraitAlias/TraitAlias_getGenericParamList.ql 5a40c1760fcf5074dc9e9efa1a543fc6223f4e5d2984923355802f91edb307e4 9fd7ab65c1d6affe19f96b1037ec3fb9381e90f602dd4611bb958048710601fa
 test/extractor-tests/generated/TraitAlias/TraitAlias_getName.ql e91fa621774b9467ae820f3c408191ac75ad33dd73bcd417d299006a84c1a069 113e0c5dd2e3ac2ddb1fd6b099b9b5c91d5cdd4a02e62d4eb8e575096f7f4c6a
 test/extractor-tests/generated/TraitAlias/TraitAlias_getTypeBoundList.ql 9ab4c329b25ea5e1a899b8698093f404ee9c095f0b0e38011161ca6480cd10a7 95c3b93610cdc08a0e251ab1307523f8cfb5560460923c81aace8619e30746dd
@@ -1065,17 +1103,15 @@ test/extractor-tests/generated/TupleFieldList/TupleFieldList.ql 7dc88440222ff036
 test/extractor-tests/generated/TupleFieldList/TupleFieldList_getField.ql ad552a9c0b9964d1770f14cabbb436db60ebedc3c569006542a8eae9ddb30f6d 3a8c49d629376a9b8326138836b05ee2366b1021ffd19f5be74ab023e70aa50d
 test/extractor-tests/generated/TuplePat/TuplePat.ql 24ee56bc848537da65eb8ecef71e84cc351a2aedcc31d6fb53a5b7865f15f7c2 81db1076e2e4921ceb50933b96cd7b574caab1818de257c1e9038f3f97447d59
 test/extractor-tests/generated/TuplePat/TuplePat_getField.ql f000bed41af031bc56d0705ce312abe7ab3dc6745b2936798c9938781e51475e f464a84dbc36aa371d60d6db68d6251f6b275dc4ecebdc56f195637be390b067
-test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql 967409c7bddd7fc8d0b9fdfab2f5e6c82e8b4ff57020822aa0cda177244dfbc5 eaf0b7e56c38db60fafb39f8de75b67ee1099ac540fa92b5dfe84b601d31781a
+test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql 10be4d7ddc82b437209b945b04a602e57fdeaf1b6b3ccff7d6f3bce08acbe1eb c86e1d3c38408eaba8bf234c2f11467557a4ada315c20c3ec175f42eaeea582f
 test/extractor-tests/generated/TupleStructPat/TupleStructPat_getField.ql f3f2e23cc2a32aa5abc1e0fda1300dab1693230632b9eaa75bb3b1e82ee9ea1a 24b87a39ec639a26ff8c1d04dc3429b72266b2a3b1650a06a7cd4387b6f0e615
 test/extractor-tests/generated/TupleStructPat/TupleStructPat_getPath.ql 13a06696bbf1fa8d5b73107e28cdba40e93da04b27f9c54381b78a52368d2ad1 5558c35ea9bb371ad90a5b374d7530dd1936f83e6ba656ebfbfd5bd63598e088
-test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCrateOrigin.ql e409667233331a038e482de4b2669d9fac9d7eb0e3bd5580ea19828f0c4ed7ad 588e4628471f1004575900d7365490efcf9168b555ff26becfc3f27b9e657de3
-test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedPath.ql 150898b6e55cc74b9ddb947f136b5a7f538ee5598928c5724d80e3ddf93ae499 66e0bd7b32df8f5bbe229cc02be6a07cb9ec0fe8b444dad3f5b32282a90551ee
+test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCanonicalPath.ql 91b4b1b562c33a07ff3007346c4cb9833149263dd196995b3b0e00894abb87f7 fa8c8d6b34277d53bf5ff211c54e1a634d0c215288185802fc3fbdd19c945f22
 test/extractor-tests/generated/TupleTypeRepr/TupleTypeRepr.ql 2f99917a95a85a932f423cba5a619a51cada8e704b93c54b0a8cb5d7a1129fa1 759bd02347c898139ac7dabe207988eea125be24d3e4c2282b791ec810c16ea7
 test/extractor-tests/generated/TupleTypeRepr/TupleTypeRepr_getField.ql 615acfcbc475b5c2ffa8e46d023fc2e19d29ee879b4949644a7f0b25c33125e6 81b037af5dcb8a0489a7a81a0ad668ca781b71d4406c123c4f1c4f558722f13e
-test/extractor-tests/generated/TypeAlias/TypeAlias.ql 637d4c982691942fabcc99ef4a1765ec794d1271bdd376addb55c9d7ea31230e ef81773e2f1260f66f23ce537080c3273b1cf74f96fba37403d34dc1ee1e0458
+test/extractor-tests/generated/TypeAlias/TypeAlias.ql 4000cf08561ccc45230b2995e63e7278804536b6bec1a28567ff0e33fa9b5155 398ab83e01b8774d881f73c85c27fa0ee9723502271ec2616d6dd93b15b27e52
 test/extractor-tests/generated/TypeAlias/TypeAlias_getAttr.ql ecf4b45ef4876e46252785d2e42b11207e65757cdb26e60decafd765e7b03b49 21bb4d635d3d38abd731b9ad1a2b871f8e0788f48a03e9572823abeea0ea9382
-test/extractor-tests/generated/TypeAlias/TypeAlias_getCrateOrigin.ql cd66db5b43bcb46a6cf6db8c262fd524017ef67cdb67c010af61fab303e3bc65 2aebae618448530ec537709c5381359ea98399db83eeae3be88825ebefa1829d
-test/extractor-tests/generated/TypeAlias/TypeAlias_getExtendedCanonicalPath.ql fe9c4132e65b54eb071b779e508e9ed0081d860df20f8d4748332b45b7215fd5 448c10c3f8f785c380ce430996af4040419d8dccfa86f75253b6af83d2c8f1c9
+test/extractor-tests/generated/TypeAlias/TypeAlias_getCanonicalPath.ql b0872bf645d780a2d3fa048b0e9958acab8453e177f571512e1f7963c466f5e0 c60a61b71f691132ffcc88d67038d7cdb0df5dee9940321f6e084845dd82e91d
 test/extractor-tests/generated/TypeAlias/TypeAlias_getGenericParamList.ql e7e936458dce5a8c6675485a49e2769b6dbff29c112ed744c880e0fc7ae740ef e5fcf3a33d2416db6b0a73401a3cbc0cece22d0e06794e01a1645f2b3bca9306
 test/extractor-tests/generated/TypeAlias/TypeAlias_getName.ql 757deb3493764677de3eb1ff7cc119a469482b7277ed01eb8aa0c38b4a8797fb 5efed24a6968544b10ff44bfac7d0432a9621bde0e53b8477563d600d4847825
 test/extractor-tests/generated/TypeAlias/TypeAlias_getTypeBoundList.ql 309efaa32a840fb1fca7d34b7cdbbf51ab469707fa195b69a9f1a7d141db3a02 e12bf44d8858e930bdde80ecd7909b5405a51a1b00a6d2c8ee880e68dd622075
@@ -1097,19 +1133,17 @@ test/extractor-tests/generated/TypeParam/TypeParam_getName.ql 9d5b6d6a9f2a5793e2
 test/extractor-tests/generated/TypeParam/TypeParam_getTypeBoundList.ql 080a6b370ad460bf128fdfd632aa443af2ad91c3483e192ad756eb234dbfa4d8 8b048d282963f670db357f1eef9b8339f83d03adf57489a22b441d5c782aff62
 test/extractor-tests/generated/UnderscoreExpr/UnderscoreExpr.ql 4ad6ed0c803fb4f58094a55b866940b947b16259756c674200172551ee6546e0 d3270bdcc4c026325159bd2a59848eb51d96298b2bf21402ea0a83ac1ea6d291
 test/extractor-tests/generated/UnderscoreExpr/UnderscoreExpr_getAttr.ql d8502be88bcd97465f387c410b5078a4709e32b2baa556a4918ea5e609c40dd7 b238dc37404254e3e7806d50a7b1453e17e71da122931331b16a55853d3a843f
-test/extractor-tests/generated/Union/Union.ql 1049e542ca7723490d05e20b5a7a5867f74a5126395f333eae512aeb05efefd6 1f1cd82337e7ade9d02d16123201bbff62983c537672b5c1babfe6b65d300e82
+test/extractor-tests/generated/Union/Union.ql 2c78d68026772c8bcfe9fccce8e51bfb895a8fa19d6502b618f31b3f0e7d26b5 940acf8960ecab4705933ac8617439dc8aa20e09af5737e52d40df2e3054d9bb
 test/extractor-tests/generated/Union/Union_getAttr.ql 42fa0878a6566208863b1d884baf7b68b46089827fdb1dbbfacbfccf5966a9a2 54aa94f0281ca80d1a4bdb0e2240f4384af2ab8d50f251875d1877d0964579fc
-test/extractor-tests/generated/Union/Union_getCrateOrigin.ql c218308cf17b1490550229a725542d248617661b1a5fa14e9b0e18d29c5ecc00 e0489242c8ff7aa4dbfdebcd46a5e0d9bea0aa618eb0617e76b9b6f863a2907a
-test/extractor-tests/generated/Union/Union_getExtendedCanonicalPath.ql 6268ddb68c3e05906e3fc85e40635925b84e5c7290746ded9c6814d362033068 04473b3b9891012e95733463018db8da0e96659ea0b10458b33dc857c091d278
+test/extractor-tests/generated/Union/Union_getCanonicalPath.ql a08fb3f3305be82ffca880bd66b6b938783b23d5d4ef5f404f79df27c306fa8f c435480ae375a559b02c1a459c04a95e7aaab617cf5168c14f634946bccdb1dc
 test/extractor-tests/generated/Union/Union_getGenericParamList.ql c55156ae26b766e385be7d21e67f8c3c45c29274201c93d660077fcc47e1ceee 4c4d338e17c32876ef6e51fd19cff67d125dd89c10e939dfaadbac824bef6a68
 test/extractor-tests/generated/Union/Union_getName.ql 17247183e1a8c8bbb15e67120f65ca323630bddeb614fa8a48e1e74319f8ed37 e21c2a0205bc991ba86f3e508451ef31398bdf5441f6d2a3f72113aaae9e152b
 test/extractor-tests/generated/Union/Union_getRecordFieldList.ql ded2890094adaa627be35f2a8335abbe5c1d4b5dcf1671f09f504546148cc02e 1f0d94a5c3259b8c39f2a78f1f9250655c6183a5277131a7f3de14126eee6d03
 test/extractor-tests/generated/Union/Union_getVisibility.ql 86628736a677343d816e541ba76db02bdae3390f8367c09be3c1ff46d1ae8274 6514cdf4bfad8d9c968de290cc981be1063c0919051822cc6fdb03e8a891f123
 test/extractor-tests/generated/Union/Union_getWhereClause.ql 508e68ffa87f4eca2e2f9c894d215ea76070d628a294809dc267082b9e36a359 29da765d11794441a32a5745d4cf594495a9733e28189d898f64da864817894f
-test/extractor-tests/generated/Use/Use.ql b20f6221e6ee731718eb9a02fa765f298ad285f23393a3df0119707c48edd8b3 9ab45d9b3c51c6181a6609b72ebd763c336fee01b11757e7f044257510bd7f3f
+test/extractor-tests/generated/Use/Use.ql 560bdfb307ea85ed4f3785081a67d21cac4e2156da15a704f266f54675e5e5b3 ac71b0b68cc1c3b1f36bc975cf9b24dfff8be6d95e0e2d7e1d7a7b314b36f7d0
 test/extractor-tests/generated/Use/Use_getAttr.ql 6d43c25401398108553508aabb32ca476b3072060bb73eb07b1b60823a01f964 84e6f6953b4aa9a7472082f0a4f2df26ab1d157529ab2c661f0031603c94bb1d
-test/extractor-tests/generated/Use/Use_getCrateOrigin.ql 912ebc1089aa3390d4142a39ea73d5490eae525d1fb51654fdd05e9dd48a94b6 c59e36362016ae536421e6d517889cea0b2670818ea1f9e997796f51a9b381e2
-test/extractor-tests/generated/Use/Use_getExtendedCanonicalPath.ql ccfde95c861cf4199e688b6efeeee9dab58a27cfecd520e39cc20f89143c03c9 6ff93df4134667d7cb74ae7efe102fe2db3ad4c67b4b5a0f8955f21997806f16
+test/extractor-tests/generated/Use/Use_getCanonicalPath.ql 091e3cd46980ed847b9b2716ae53da0c62da7f3d5a040c112c77639bbd7f7335 924893d23c76c1c21228d5083a34991c40146f2f67be26e2648b7e33e2e3785d
 test/extractor-tests/generated/Use/Use_getUseTree.ql 1dfe6bb40b29fbf823d67fecfc36ba928b43f17c38227b8eedf19fa252edf3af aacdcc4cf418ef1eec267287d2af905fe73f5bcfb080ef5373d08da31c608720
 test/extractor-tests/generated/Use/Use_getVisibility.ql 587f80acdd780042c48aeb347004be5e9fd9df063d263e6e4f2b660c48c53a8f 0c2c04f95838bca93dfe93fa208e1df7677797efc62b4e8052a4f9c5d20831dd
 test/extractor-tests/generated/UseTree/UseTree.ql cb9f63051ae08cf8557b86b69b02cefe1732fc1e2daec34bcb891e271829cd86 eb46496aab9252b21eb0ccdd75792a97264885259c23d7e17e3013d943783947
@@ -1118,11 +1152,10 @@ test/extractor-tests/generated/UseTree/UseTree_getRename.ql ec3917501f3c89ac4974
 test/extractor-tests/generated/UseTree/UseTree_getUseTreeList.ql c265a88347e813840969ae934dfd2904bc06f502de77709bc0b1c7255e46382a 52a239c8ea5fd8fbfbd606559d70ecadc769887437a9bcab6fb3e774208ad868
 test/extractor-tests/generated/UseTreeList/UseTreeList.ql cd943c15c86e66244caafeb95b960a5c3d351d5edbd506258744fb60a61af3b2 cfa584cd9d8aa08267fd1106745a66226b2c99fadd1da65059cc7ecf2f2e68cf
 test/extractor-tests/generated/UseTreeList/UseTreeList_getUseTree.ql dd72966b1cb7b04f0267503013809063fcfb145e2b2d7d5250d9f24d2e405f9a 75b953aa11c51ca0fe95e67d50d6238962d8df4a4b9054999a2c6338e5a5613d
-test/extractor-tests/generated/Variant/Variant.ql c60dd31adac91e09f8b1e5523d6b859747e64ef072c077b5a3326763f9f461f7 55d6446a3a831ed1137264678c5df027eb94cb3570a88d364994851fe6236999
+test/extractor-tests/generated/Variant/Variant.ql dbce5711476e1169f86d01f45fa41ed0e493c6adab1e26f163a31f19b33692cc 4d8dc13b17617367ebc9837b8d2ba461363ef807ddb3a5fa263975552a0902a8
 test/extractor-tests/generated/Variant/Variant_getAttr.ql dd38e48e1eb05ce280b880652a90010eb63f7de3be7232411ba6265691249420 f8980680104de1e5fd40f264d8d62346aacaf6403a5e051f6fd680e234c82c1f
-test/extractor-tests/generated/Variant/Variant_getCrateOrigin.ql 99e79930f8ff87a25f256926e5c3ce1ee0847daf6fadc5445fb33c85328b4c61 2dd64a53813790654c83be25b5e175c9c5b388e758723c2138fff095353fdd7b
+test/extractor-tests/generated/Variant/Variant_getCanonicalPath.ql b8177f13ba56964ff621016395b7095daf3121fd21f6a5db5104f21c8d388774 64aae1b34f459bff5edf483ff4f7407bea218c12df7ed4e6d54974f6fc7a77bb
 test/extractor-tests/generated/Variant/Variant_getExpr.ql ce00af303d28f60c5fd1dc7df628c7974aced21884e223a2f656cb4f0d1a74d5 9de51a65510cf9a15801d4207b616915bd959c95ec7330fdb502c5dff5b650cc
-test/extractor-tests/generated/Variant/Variant_getExtendedCanonicalPath.ql fe6a4bfd1440e7629d47283910de84c5e8c2f5645512780e710f53540b5bc886 b1e31b765cb1a5fe063abb8c1b2115e881ae28aa3ccd39e088ff8f2af20d6cf4
 test/extractor-tests/generated/Variant/Variant_getFieldList.ql 083c8cf61989663de33d99b72dec231c308ccc8bb6739921465c473a07e8ea03 d03bff6945853c940acdc053b813d53b008ddab9a8bd4307826433828d4763ce
 test/extractor-tests/generated/Variant/Variant_getName.ql 0d7b47bec9f9031c67f7b684112a84a311ef9b2efeb260bd7cd6f424011ca0d8 73565e6f965dd7fd7bb9b3408c7d7b69120e1971b67ab307fed293eb663a59ae
 test/extractor-tests/generated/Variant/Variant_getVisibility.ql 2c8f365d28d96af55589f4d71ac3fee718b319b4cbc784560c0591d1f605a119 13160d9cf39fe169410eff6c338f5d063e1948109e8f18dd33ea0064f1dd9283
diff --git a/rust/ql/.gitattributes b/rust/ql/.gitattributes
index 49142cf2701d..01f48fe54ed9 100644
--- a/rust/ql/.gitattributes
+++ b/rust/ql/.gitattributes
@@ -174,9 +174,46 @@
 /lib/codeql/rust/elements/WildcardPat.qll linguist-generated
 /lib/codeql/rust/elements/YeetExpr.qll linguist-generated
 /lib/codeql/rust/elements/YieldExpr.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/BuiltinTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/CanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/CanonicalPathElement.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/ConcreteTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/ConstGenericTypeArg.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/CrateRef.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/DerivedTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/LangCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/ModuleItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/Namespace.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/ParametrizedCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/PlaceholderTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/RepoCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/RustcCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TraitImplItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TypeGenericArg.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TypeGenericTypeArg.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TypeImplItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/TypeItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathImpl.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/CrateRefImpl.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRefConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/NamespaceConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRefConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRefConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/TypeCanonicalPathImpl.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathConstructor.qll linguist-generated
+/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathConstructor.qll linguist-generated
 /lib/codeql/rust/elements/internal/AbiConstructor.qll linguist-generated
 /lib/codeql/rust/elements/internal/AbiImpl.qll linguist-generated
-/lib/codeql/rust/elements/internal/AddressableImpl.qll linguist-generated
 /lib/codeql/rust/elements/internal/ArgListConstructor.qll linguist-generated
 /lib/codeql/rust/elements/internal/ArgListImpl.qll linguist-generated
 /lib/codeql/rust/elements/internal/ArrayExprInternal.qll linguist-generated
@@ -598,6 +635,26 @@
 /lib/codeql/rust/elements/internal/generated/WildcardPat.qll linguist-generated
 /lib/codeql/rust/elements/internal/generated/YeetExpr.qll linguist-generated
 /lib/codeql/rust/elements/internal/generated/YieldExpr.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/BuiltinTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPathElement.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/ConcreteTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/ConstGenericTypeArg.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/CrateRef.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/DerivedTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/LangCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/ModuleItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/Namespace.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/ParametrizedCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/PlaceholderTypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/RepoCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/RustcCrateRef.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TraitImplItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericArg.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericTypeArg.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeImplItemCanonicalPath.qll linguist-generated
+/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeItemCanonicalPath.qll linguist-generated
 /lib/codeql/rust/elements.qll linguist-generated
 /test/extractor-tests/generated/Abi/Abi.ql linguist-generated
 /test/extractor-tests/generated/Abi/Abi_getAbiString.ql linguist-generated
@@ -667,8 +724,7 @@
 /test/extractor-tests/generated/Const/Const.ql linguist-generated
 /test/extractor-tests/generated/Const/Const_getAttr.ql linguist-generated
 /test/extractor-tests/generated/Const/Const_getBody.ql linguist-generated
-/test/extractor-tests/generated/Const/Const_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Const/Const_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Const/Const_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Const/Const_getName.ql linguist-generated
 /test/extractor-tests/generated/Const/Const_getTypeRepr.ql linguist-generated
 /test/extractor-tests/generated/Const/Const_getVisibility.ql linguist-generated
@@ -688,8 +744,7 @@
 /test/extractor-tests/generated/DynTraitTypeRepr/DynTraitTypeRepr_getTypeBoundList.ql linguist-generated
 /test/extractor-tests/generated/Enum/Enum.ql linguist-generated
 /test/extractor-tests/generated/Enum/Enum_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Enum/Enum_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Enum/Enum_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Enum/Enum_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Enum/Enum_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Enum/Enum_getName.ql linguist-generated
 /test/extractor-tests/generated/Enum/Enum_getVariantList.ql linguist-generated
@@ -700,13 +755,11 @@
 /test/extractor-tests/generated/ExternBlock/ExternBlock.ql linguist-generated
 /test/extractor-tests/generated/ExternBlock/ExternBlock_getAbi.ql linguist-generated
 /test/extractor-tests/generated/ExternBlock/ExternBlock_getAttr.ql linguist-generated
-/test/extractor-tests/generated/ExternBlock/ExternBlock_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/ExternBlock/ExternBlock_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/ExternBlock/ExternBlock_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/ExternBlock/ExternBlock_getExternItemList.ql linguist-generated
 /test/extractor-tests/generated/ExternCrate/ExternCrate.ql linguist-generated
 /test/extractor-tests/generated/ExternCrate/ExternCrate_getAttr.ql linguist-generated
-/test/extractor-tests/generated/ExternCrate/ExternCrate_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/ExternCrate/ExternCrate_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/ExternCrate/ExternCrate_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/ExternCrate/ExternCrate_getNameRef.ql linguist-generated
 /test/extractor-tests/generated/ExternCrate/ExternCrate_getRename.ql linguist-generated
 /test/extractor-tests/generated/ExternCrate/ExternCrate_getVisibility.ql linguist-generated
@@ -747,8 +800,7 @@
 /test/extractor-tests/generated/Function/Function_getAbi.ql linguist-generated
 /test/extractor-tests/generated/Function/Function_getAttr.ql linguist-generated
 /test/extractor-tests/generated/Function/Function_getBody.ql linguist-generated
-/test/extractor-tests/generated/Function/Function_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Function/Function_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Function/Function_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Function/Function_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Function/Function_getName.ql linguist-generated
 /test/extractor-tests/generated/Function/Function_getParamList.ql linguist-generated
@@ -771,8 +823,7 @@
 /test/extractor-tests/generated/Impl/Impl.ql linguist-generated
 /test/extractor-tests/generated/Impl/Impl_getAssocItemList.ql linguist-generated
 /test/extractor-tests/generated/Impl/Impl_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Impl/Impl_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Impl/Impl_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Impl/Impl_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Impl/Impl_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Impl/Impl_getSelfTy.ql linguist-generated
 /test/extractor-tests/generated/Impl/Impl_getTrait.ql linguist-generated
@@ -821,17 +872,15 @@
 /test/extractor-tests/generated/LoopExpr/LoopExpr_getLoopBody.ql linguist-generated
 /test/extractor-tests/generated/MacroCall/MacroCall.ql linguist-generated
 /test/extractor-tests/generated/MacroCall/MacroCall_getAttr.ql linguist-generated
-/test/extractor-tests/generated/MacroCall/MacroCall_getCrateOrigin.ql linguist-generated
+/test/extractor-tests/generated/MacroCall/MacroCall_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/MacroCall/MacroCall_getExpanded.ql linguist-generated
-/test/extractor-tests/generated/MacroCall/MacroCall_getExtendedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/MacroCall/MacroCall_getPath.ql linguist-generated
 /test/extractor-tests/generated/MacroCall/MacroCall_getTokenTree.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef_getArgs.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef_getAttr.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef_getBody.ql linguist-generated
-/test/extractor-tests/generated/MacroDef/MacroDef_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/MacroDef/MacroDef_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/MacroDef/MacroDef_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef_getName.ql linguist-generated
 /test/extractor-tests/generated/MacroDef/MacroDef_getVisibility.ql linguist-generated
 /test/extractor-tests/generated/MacroExpr/MacroExpr.ql linguist-generated
@@ -842,8 +891,7 @@
 /test/extractor-tests/generated/MacroPat/MacroPat_getMacroCall.ql linguist-generated
 /test/extractor-tests/generated/MacroRules/MacroRules.ql linguist-generated
 /test/extractor-tests/generated/MacroRules/MacroRules_getAttr.ql linguist-generated
-/test/extractor-tests/generated/MacroRules/MacroRules_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/MacroRules/MacroRules_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/MacroRules/MacroRules_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/MacroRules/MacroRules_getName.ql linguist-generated
 /test/extractor-tests/generated/MacroRules/MacroRules_getTokenTree.ql linguist-generated
 /test/extractor-tests/generated/MacroRules/MacroRules_getVisibility.ql linguist-generated
@@ -876,12 +924,10 @@
 /test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getGenericArgList.ql linguist-generated
 /test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getNameRef.ql linguist-generated
 /test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getReceiver.ql linguist-generated
-/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Module/Module.ql linguist-generated
 /test/extractor-tests/generated/Module/Module_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Module/Module_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Module/Module_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Module/Module_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Module/Module_getItemList.ql linguist-generated
 /test/extractor-tests/generated/Module/Module_getName.ql linguist-generated
 /test/extractor-tests/generated/Module/Module_getVisibility.ql linguist-generated
@@ -914,12 +960,10 @@
 /test/extractor-tests/generated/Path/PathExpr.ql linguist-generated
 /test/extractor-tests/generated/Path/PathExpr_getAttr.ql linguist-generated
 /test/extractor-tests/generated/Path/PathExpr_getPath.ql linguist-generated
-/test/extractor-tests/generated/Path/PathExpr_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Path/PathExpr_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Path/PathPat.ql linguist-generated
 /test/extractor-tests/generated/Path/PathPat_getPath.ql linguist-generated
-/test/extractor-tests/generated/Path/PathPat_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Path/PathPat_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Path/PathSegment.ql linguist-generated
 /test/extractor-tests/generated/Path/PathSegment_getGenericArgList.ql linguist-generated
 /test/extractor-tests/generated/Path/PathSegment_getNameRef.ql linguist-generated
@@ -950,8 +994,7 @@
 /test/extractor-tests/generated/RecordExpr/RecordExpr.ql linguist-generated
 /test/extractor-tests/generated/RecordExpr/RecordExpr_getPath.ql linguist-generated
 /test/extractor-tests/generated/RecordExpr/RecordExpr_getRecordExprFieldList.ql linguist-generated
-/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/RecordExprField/RecordExprField.ql linguist-generated
 /test/extractor-tests/generated/RecordExprField/RecordExprField_getAttr.ql linguist-generated
 /test/extractor-tests/generated/RecordExprField/RecordExprField_getExpr.ql linguist-generated
@@ -970,8 +1013,7 @@
 /test/extractor-tests/generated/RecordPat/RecordPat.ql linguist-generated
 /test/extractor-tests/generated/RecordPat/RecordPat_getPath.ql linguist-generated
 /test/extractor-tests/generated/RecordPat/RecordPat_getRecordPatFieldList.ql linguist-generated
-/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/RecordPatField/RecordPatField.ql linguist-generated
 /test/extractor-tests/generated/RecordPatField/RecordPatField_getAttr.ql linguist-generated
 /test/extractor-tests/generated/RecordPatField/RecordPatField_getNameRef.ql linguist-generated
@@ -1012,8 +1054,7 @@
 /test/extractor-tests/generated/Static/Static.ql linguist-generated
 /test/extractor-tests/generated/Static/Static_getAttr.ql linguist-generated
 /test/extractor-tests/generated/Static/Static_getBody.ql linguist-generated
-/test/extractor-tests/generated/Static/Static_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Static/Static_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Static/Static_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Static/Static_getName.ql linguist-generated
 /test/extractor-tests/generated/Static/Static_getTypeRepr.ql linguist-generated
 /test/extractor-tests/generated/Static/Static_getVisibility.ql linguist-generated
@@ -1023,8 +1064,7 @@
 /test/extractor-tests/generated/StmtList/StmtList_getTailExpr.ql linguist-generated
 /test/extractor-tests/generated/Struct/Struct.ql linguist-generated
 /test/extractor-tests/generated/Struct/Struct_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Struct/Struct_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Struct/Struct_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Struct/Struct_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Struct/Struct_getFieldList.ql linguist-generated
 /test/extractor-tests/generated/Struct/Struct_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Struct/Struct_getName.ql linguist-generated
@@ -1037,8 +1077,7 @@
 /test/extractor-tests/generated/Trait/Trait.ql linguist-generated
 /test/extractor-tests/generated/Trait/Trait_getAssocItemList.ql linguist-generated
 /test/extractor-tests/generated/Trait/Trait_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Trait/Trait_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Trait/Trait_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Trait/Trait_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Trait/Trait_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Trait/Trait_getName.ql linguist-generated
 /test/extractor-tests/generated/Trait/Trait_getTypeBoundList.ql linguist-generated
@@ -1046,8 +1085,7 @@
 /test/extractor-tests/generated/Trait/Trait_getWhereClause.ql linguist-generated
 /test/extractor-tests/generated/TraitAlias/TraitAlias.ql linguist-generated
 /test/extractor-tests/generated/TraitAlias/TraitAlias_getAttr.ql linguist-generated
-/test/extractor-tests/generated/TraitAlias/TraitAlias_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/TraitAlias/TraitAlias_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/TraitAlias/TraitAlias_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/TraitAlias/TraitAlias_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/TraitAlias/TraitAlias_getName.ql linguist-generated
 /test/extractor-tests/generated/TraitAlias/TraitAlias_getTypeBoundList.ql linguist-generated
@@ -1070,14 +1108,12 @@
 /test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql linguist-generated
 /test/extractor-tests/generated/TupleStructPat/TupleStructPat_getField.ql linguist-generated
 /test/extractor-tests/generated/TupleStructPat/TupleStructPat_getPath.ql linguist-generated
-/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedPath.ql linguist-generated
+/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/TupleTypeRepr/TupleTypeRepr.ql linguist-generated
 /test/extractor-tests/generated/TupleTypeRepr/TupleTypeRepr_getField.ql linguist-generated
 /test/extractor-tests/generated/TypeAlias/TypeAlias.ql linguist-generated
 /test/extractor-tests/generated/TypeAlias/TypeAlias_getAttr.ql linguist-generated
-/test/extractor-tests/generated/TypeAlias/TypeAlias_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/TypeAlias/TypeAlias_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/TypeAlias/TypeAlias_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/TypeAlias/TypeAlias_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/TypeAlias/TypeAlias_getName.ql linguist-generated
 /test/extractor-tests/generated/TypeAlias/TypeAlias_getTypeBoundList.ql linguist-generated
@@ -1101,8 +1137,7 @@
 /test/extractor-tests/generated/UnderscoreExpr/UnderscoreExpr_getAttr.ql linguist-generated
 /test/extractor-tests/generated/Union/Union.ql linguist-generated
 /test/extractor-tests/generated/Union/Union_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Union/Union_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Union/Union_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Union/Union_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Union/Union_getGenericParamList.ql linguist-generated
 /test/extractor-tests/generated/Union/Union_getName.ql linguist-generated
 /test/extractor-tests/generated/Union/Union_getRecordFieldList.ql linguist-generated
@@ -1110,8 +1145,7 @@
 /test/extractor-tests/generated/Union/Union_getWhereClause.ql linguist-generated
 /test/extractor-tests/generated/Use/Use.ql linguist-generated
 /test/extractor-tests/generated/Use/Use_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Use/Use_getCrateOrigin.ql linguist-generated
-/test/extractor-tests/generated/Use/Use_getExtendedCanonicalPath.ql linguist-generated
+/test/extractor-tests/generated/Use/Use_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Use/Use_getUseTree.ql linguist-generated
 /test/extractor-tests/generated/Use/Use_getVisibility.ql linguist-generated
 /test/extractor-tests/generated/UseTree/UseTree.ql linguist-generated
@@ -1122,9 +1156,8 @@
 /test/extractor-tests/generated/UseTreeList/UseTreeList_getUseTree.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant_getAttr.ql linguist-generated
-/test/extractor-tests/generated/Variant/Variant_getCrateOrigin.ql linguist-generated
+/test/extractor-tests/generated/Variant/Variant_getCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant_getExpr.ql linguist-generated
-/test/extractor-tests/generated/Variant/Variant_getExtendedCanonicalPath.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant_getFieldList.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant_getName.ql linguist-generated
 /test/extractor-tests/generated/Variant/Variant_getVisibility.ql linguist-generated
diff --git a/rust/ql/lib/codeql/rust/dataflow/FlowSummary.qll b/rust/ql/lib/codeql/rust/dataflow/FlowSummary.qll
index d1ba69ba22d2..37b50fc6e3bd 100644
--- a/rust/ql/lib/codeql/rust/dataflow/FlowSummary.qll
+++ b/rust/ql/lib/codeql/rust/dataflow/FlowSummary.qll
@@ -19,14 +19,20 @@ module LibraryCallable {
 
     /** Gets a call to this library callable. */
     CallExprBase getACall() {
-      exists(Resolvable r, string crate |
-        r = CallExprBaseImpl::getCallResolvable(result) and
-        this = crate + r.getResolvedPath()
+      exists(
+        TypeItemCanonicalPath path, ModuleItemCanonicalPath item, Namespace namespace,
+        string namespace_path
       |
-        crate = r.getResolvedCrateOrigin() + "::_::"
-        or
-        not r.hasResolvedCrateOrigin() and
-        crate = ""
+        path = CallExprBaseImpl::getCallResolvable(result).getResolvedCanonicalPath() and
+        item = path.getParent() and
+        namespace = item.getNamespace() and
+        namespace_path = namespace.getPath() and
+        if namespace_path = ""
+        then this = namespace.getRoot().toString() + "::" + item.getName() + "::" + path.getName()
+        else
+          this =
+            namespace.getRoot().toString() + "::" + namespace_path + "::" + item.getName() + "::" +
+              path.getName()
       )
     }
   }
diff --git a/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll b/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll
index a36afb4450f5..f1dd8d7d5fe6 100644
--- a/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll
+++ b/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll
@@ -566,45 +566,6 @@ module LocalFlow {
 
 private import codeql.util.Option
 
-private class CrateOrigin extends string {
-  CrateOrigin() {
-    this = [any(Item i).getCrateOrigin(), any(Resolvable r).getResolvedCrateOrigin()]
-  }
-}
-
-private class CrateOriginOption = Option<CrateOrigin>::Option;
-
-pragma[nomagic]
-private predicate hasExtendedCanonicalPath(Item i, CrateOriginOption crate, string path) {
-  path = i.getExtendedCanonicalPath() and
-  (
-    crate.asSome() = i.getCrateOrigin()
-    or
-    crate.isNone() and
-    not i.hasCrateOrigin()
-  )
-}
-
-pragma[nomagic]
-private predicate variantHasExtendedCanonicalPath(
-  Enum e, Variant v, CrateOriginOption crate, string path, string name
-) {
-  hasExtendedCanonicalPath(e, crate, path) and
-  v = e.getVariantList().getAVariant() and
-  name = v.getName().getText()
-}
-
-pragma[nomagic]
-private predicate resolveExtendedCanonicalPath(Resolvable r, CrateOriginOption crate, string path) {
-  path = r.getResolvedPath() and
-  (
-    crate.asSome() = r.getResolvedCrateOrigin()
-    or
-    crate.isNone() and
-    not r.hasResolvedCrateOrigin()
-  )
-}
-
 /**
  * A path to a value contained in an object. For example a field name of a struct.
  */
@@ -615,16 +576,16 @@ abstract class Content extends TContent {
 
 /** A canonical path pointing to an enum variant. */
 class VariantCanonicalPath extends MkVariantCanonicalPath {
-  CrateOriginOption crate;
-  string path;
+  string namespace;
+  string enum;
   string name;
 
-  VariantCanonicalPath() { this = MkVariantCanonicalPath(crate, path, name) }
+  VariantCanonicalPath() { this = MkVariantCanonicalPath(namespace, enum, name) }
 
   /** Gets the underlying variant. */
-  Variant getVariant() { variantHasExtendedCanonicalPath(_, result, crate, path, name) }
+  Variant getVariant() { result.hasStandardPath(namespace, enum, name) }
 
-  string getExtendedCanonicalPath() { result = path + "::" + name }
+  string getCanonicalPath() { result = namespace + "::" + enum + "::" + name }
 
   string toString() { result = name }
 
@@ -673,17 +634,17 @@ private class VariantFieldContent extends VariantContent, TVariantFieldContent {
 
 /** A canonical path pointing to a struct. */
 class StructCanonicalPath extends MkStructCanonicalPath {
-  CrateOriginOption crate;
-  string path;
+  string namespace;
+  string name;
 
-  StructCanonicalPath() { this = MkStructCanonicalPath(crate, path) }
+  StructCanonicalPath() { this = MkStructCanonicalPath(namespace, name) }
 
   /** Gets the underlying struct. */
-  Struct getStruct() { hasExtendedCanonicalPath(result, crate, path) }
+  Struct getStruct() { result.hasStandardPath(namespace, name) }
 
-  string getExtendedCanonicalPath() { result = path }
+  string getCanonicalPath() { result = namespace + "::" + name }
 
-  string toString() { result = this.getStruct().getName().getText() }
+  string toString() { result = name }
 
   Location getLocation() { result = this.getStruct().getLocation() }
 }
@@ -948,17 +909,17 @@ module RustDataFlow implements InputSig<Location> {
 
   /** Holds if path `p` resolves to struct `s`. */
   private predicate pathResolveToStructCanonicalPath(PathAstNode p, StructCanonicalPath s) {
-    exists(CrateOriginOption crate, string path |
-      resolveExtendedCanonicalPath(p, crate, path) and
-      s = MkStructCanonicalPath(crate, path)
+    exists(string namespace, string name |
+      p.resolvesToStandardPath(namespace, name) and
+      s = MkStructCanonicalPath(namespace, name)
     )
   }
 
   /** Holds if path `p` resolves to variant `v`. */
   private predicate pathResolveToVariantCanonicalPath(PathAstNode p, VariantCanonicalPath v) {
-    exists(CrateOriginOption crate, string path, string name |
-      resolveExtendedCanonicalPath(p, crate, path + "::" + name) and
-      v = MkVariantCanonicalPath(crate, path, name)
+    exists(string namespace, string enum, string name |
+      p.resolvesToStandardPath(namespace, enum, name) and
+      v = MkVariantCanonicalPath(namespace, enum, name)
     )
   }
 
@@ -1036,8 +997,8 @@ module RustDataFlow implements InputSig<Location> {
       exists(TryExprCfgNode try |
         node1.asExpr() = try.getExpr() and
         node2.asExpr() = try and
-        c.(VariantPositionContent).getVariantCanonicalPath(0).getExtendedCanonicalPath() =
-          ["crate::option::Option::Some", "crate::result::Result::Ok"]
+        c.(VariantPositionContent).getVariantCanonicalPath(0).getCanonicalPath() =
+          ["std::option::Option::Some", "std::result::Result::Ok"]
       )
       or
       VariableCapture::readStep(node1, c, node2)
@@ -1431,28 +1392,27 @@ private module Cached {
   cached
   newtype TReturnKind = TNormalReturnKind()
 
-  private CrateOriginOption langCoreCrate() { result.asSome() = "lang:core" }
-
   cached
   newtype TVariantCanonicalPath =
-    MkVariantCanonicalPath(CrateOriginOption crate, string path, string name) {
-      variantHasExtendedCanonicalPath(_, _, crate, path, name)
+    MkVariantCanonicalPath(string namespace, string enum, string name) {
+      any(Variant v).hasStandardPath(namespace, enum, name)
       or
       // TODO: Remove once library types are extracted
-      crate = langCoreCrate() and
       (
-        path = "crate::option::Option" and
+        namespace = "std::option" and
+        enum = "Option" and
         name = "Some"
         or
-        path = "crate::result::Result" and
+        namespace = "std::result" and
+        enum = "Result" and
         name = ["Ok", "Err"]
       )
     }
 
   cached
   newtype TStructCanonicalPath =
-    MkStructCanonicalPath(CrateOriginOption crate, string path) {
-      exists(Struct s | hasExtendedCanonicalPath(s, crate, path))
+    MkStructCanonicalPath(string namespace, string name) {
+      any(Struct s).hasStandardPath(namespace, name)
     }
 
   cached
@@ -1461,11 +1421,11 @@ private module Cached {
       pos in [0 .. v.getVariant().getFieldList().(TupleFieldList).getNumberOfFields() - 1]
       or
       // TODO: Remove once library types are extracted
-      v = MkVariantCanonicalPath(langCoreCrate(), "crate::option::Option", "Some") and
-      pos = 0
-      or
-      // TODO: Remove once library types are extracted
-      v = MkVariantCanonicalPath(langCoreCrate(), "crate::result::Result", ["Ok", "Err"]) and
+      v =
+        [
+          MkVariantCanonicalPath("std::option", "Option", "Some"),
+          MkVariantCanonicalPath("std::result", "Result", ["Ok", "Err"])
+        ] and
       pos = 0
     } or
     TVariantFieldContent(VariantCanonicalPath v, string field) {
diff --git a/rust/ql/lib/codeql/rust/dataflow/internal/FlowSummaryImpl.qll b/rust/ql/lib/codeql/rust/dataflow/internal/FlowSummaryImpl.qll
index 492764b3cf54..613c28abf92b 100644
--- a/rust/ql/lib/codeql/rust/dataflow/internal/FlowSummaryImpl.qll
+++ b/rust/ql/lib/codeql/rust/dataflow/internal/FlowSummaryImpl.qll
@@ -24,19 +24,19 @@ module Input implements InputSig<Location, RustDataFlow> {
       exists(VariantCanonicalPath v | result = "Variant" |
         exists(int pos |
           c = TVariantPositionContent(v, pos) and
-          arg = v.getExtendedCanonicalPath() + "(" + pos + ")"
+          arg = v.getCanonicalPath() + "(" + pos + ")"
         )
         or
         exists(string field |
           c = TVariantFieldContent(v, field) and
-          arg = v.getExtendedCanonicalPath() + "::" + field
+          arg = v.getCanonicalPath() + "::" + field
         )
       )
       or
       exists(StructCanonicalPath s, string field |
         result = "Struct" and
         c = TStructFieldContent(s, field) and
-        arg = s.getExtendedCanonicalPath() + "::" + field
+        arg = s.getCanonicalPath() + "::" + field
       )
       or
       result = "ArrayElement" and
diff --git a/rust/ql/lib/codeql/rust/elements.qll b/rust/ql/lib/codeql/rust/elements.qll
index 725f044ee18e..483c42458a85 100644
--- a/rust/ql/lib/codeql/rust/elements.qll
+++ b/rust/ql/lib/codeql/rust/elements.qll
@@ -177,3 +177,23 @@ import codeql.rust.elements.WhileExpr
 import codeql.rust.elements.WildcardPat
 import codeql.rust.elements.YeetExpr
 import codeql.rust.elements.YieldExpr
+import codeql.rust.elements.canonical_paths.BuiltinTypeCanonicalPath
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.CanonicalPathElement
+import codeql.rust.elements.canonical_paths.ConcreteTypeCanonicalPath
+import codeql.rust.elements.canonical_paths.ConstGenericTypeArg
+import codeql.rust.elements.canonical_paths.CrateRef
+import codeql.rust.elements.canonical_paths.DerivedTypeCanonicalPath
+import codeql.rust.elements.canonical_paths.LangCrateRef
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+import codeql.rust.elements.canonical_paths.Namespace
+import codeql.rust.elements.canonical_paths.ParametrizedCanonicalPath
+import codeql.rust.elements.canonical_paths.PlaceholderTypeCanonicalPath
+import codeql.rust.elements.canonical_paths.RepoCrateRef
+import codeql.rust.elements.canonical_paths.RustcCrateRef
+import codeql.rust.elements.canonical_paths.TraitImplItemCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeGenericArg
+import codeql.rust.elements.canonical_paths.TypeGenericTypeArg
+import codeql.rust.elements.canonical_paths.TypeImplItemCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeItemCanonicalPath
diff --git a/rust/ql/lib/codeql/rust/elements/Addressable.qll b/rust/ql/lib/codeql/rust/elements/Addressable.qll
index c5edd19adcb0..e98690fcb168 100644
--- a/rust/ql/lib/codeql/rust/elements/Addressable.qll
+++ b/rust/ql/lib/codeql/rust/elements/Addressable.qll
@@ -5,6 +5,7 @@
 
 private import internal.AddressableImpl
 import codeql.rust.elements.AstNode
+import codeql.rust.elements.canonical_paths.CanonicalPath
 
 /**
  * Something that can be addressed by a path.
diff --git a/rust/ql/lib/codeql/rust/elements/Resolvable.qll b/rust/ql/lib/codeql/rust/elements/Resolvable.qll
index 6a2304a3be7d..9bca8808b429 100644
--- a/rust/ql/lib/codeql/rust/elements/Resolvable.qll
+++ b/rust/ql/lib/codeql/rust/elements/Resolvable.qll
@@ -5,6 +5,7 @@
 
 private import internal.ResolvableImpl
 import codeql.rust.elements.AstNode
+import codeql.rust.elements.canonical_paths.CanonicalPath
 
 /**
  * One of `PathExpr`, `RecordExpr`, `PathPat`, `RecordPat`, `TupleStructPat` or `MethodCallExpr`.
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/BuiltinTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/BuiltinTypeCanonicalPath.qll
new file mode 100644
index 000000000000..bfad938da219
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/BuiltinTypeCanonicalPath.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `BuiltinTypeCanonicalPath`.
+ */
+
+private import internal.BuiltinTypeCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * A canonical path for a builtin type.
+ */
+final class BuiltinTypeCanonicalPath = Impl::BuiltinTypeCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPath.qll
new file mode 100644
index 000000000000..25a9dda1b578
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPath.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `CanonicalPath`.
+ */
+
+private import internal.CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPathElement
+
+/**
+ * The base class for all canonical paths that can be the result of a path resolution.
+ */
+final class CanonicalPath = Impl::CanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPathElement.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPathElement.qll
new file mode 100644
index 000000000000..08fa2b65dcbb
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/CanonicalPathElement.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `CanonicalPathElement`.
+ */
+
+private import internal.CanonicalPathElementImpl
+import codeql.rust.elements.Element
+
+/**
+ * The base class for all elements in a canonical path.
+ */
+final class CanonicalPathElement = Impl::CanonicalPathElement;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/ConcreteTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/ConcreteTypeCanonicalPath.qll
new file mode 100644
index 000000000000..43f362df0722
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/ConcreteTypeCanonicalPath.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `ConcreteTypeCanonicalPath`.
+ */
+
+private import internal.ConcreteTypeCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.ParametrizedCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * A canonical path for an actual type.
+ */
+final class ConcreteTypeCanonicalPath = Impl::ConcreteTypeCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/ConstGenericTypeArg.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/ConstGenericTypeArg.qll
new file mode 100644
index 000000000000..45db4a135f18
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/ConstGenericTypeArg.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `ConstGenericTypeArg`.
+ */
+
+private import internal.ConstGenericTypeArgImpl
+import codeql.rust.elements.canonical_paths.TypeGenericArg
+
+/**
+ * A generic argument for a type that is a const.
+ */
+final class ConstGenericTypeArg = Impl::ConstGenericTypeArg;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/DerivedTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/DerivedTypeCanonicalPath.qll
new file mode 100644
index 000000000000..3682e0a2450f
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/DerivedTypeCanonicalPath.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `DerivedTypeCanonicalPath`.
+ */
+
+private import internal.DerivedTypeCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
+ */
+final class DerivedTypeCanonicalPath = Impl::DerivedTypeCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/ModuleItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/ModuleItemCanonicalPath.qll
new file mode 100644
index 000000000000..d52d982ad5a3
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/ModuleItemCanonicalPath.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `ModuleItemCanonicalPath`.
+ */
+
+private import internal.ModuleItemCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.Namespace
+
+/**
+ * A canonical path for an item defined in a module.
+ */
+final class ModuleItemCanonicalPath = Impl::ModuleItemCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/Namespace.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/Namespace.qll
new file mode 100644
index 000000000000..8a484f5f0ab4
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/Namespace.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `Namespace`.
+ */
+
+private import internal.NamespaceImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.CrateRef
+
+/**
+ * A namespace, comprised of a crate root and a possibly empty `::` separated module path.
+ */
+final class Namespace = Impl::Namespace;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/ParametrizedCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/ParametrizedCanonicalPath.qll
new file mode 100644
index 000000000000..c06bbeab1afe
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/ParametrizedCanonicalPath.qll
@@ -0,0 +1,11 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `ParametrizedCanonicalPath`.
+ */
+
+private import internal.ParametrizedCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeGenericArg
+
+final class ParametrizedCanonicalPath = Impl::ParametrizedCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/PlaceholderTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/PlaceholderTypeCanonicalPath.qll
new file mode 100644
index 000000000000..b02d80b2fe95
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/PlaceholderTypeCanonicalPath.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `PlaceholderTypeCanonicalPath`.
+ */
+
+private import internal.PlaceholderTypeCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * A placeholder for a type parameter bound in an impl.
+ */
+final class PlaceholderTypeCanonicalPath = Impl::PlaceholderTypeCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TraitImplItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TraitImplItemCanonicalPath.qll
new file mode 100644
index 000000000000..da71b7bdbd77
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TraitImplItemCanonicalPath.qll
@@ -0,0 +1,14 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TraitImplItemCanonicalPath`.
+ */
+
+private import internal.TraitImplItemCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.ParametrizedCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * A canonical path for an item defined in a trait impl.
+ */
+final class TraitImplItemCanonicalPath = Impl::TraitImplItemCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeCanonicalPath.qll
new file mode 100644
index 000000000000..9f6e1e3535da
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeCanonicalPath.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TypeCanonicalPath`.
+ */
+
+private import internal.TypeCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+
+/**
+ * The base for canonical paths for types.
+ */
+final class TypeCanonicalPath = Impl::TypeCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericArg.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericArg.qll
new file mode 100644
index 000000000000..093e2b624091
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericArg.qll
@@ -0,0 +1,12 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TypeGenericArg`.
+ */
+
+private import internal.TypeGenericArgImpl
+import codeql.rust.elements.canonical_paths.CanonicalPathElement
+
+/**
+ * A generic argument for a type.
+ */
+final class TypeGenericArg = Impl::TypeGenericArg;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericTypeArg.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericTypeArg.qll
new file mode 100644
index 000000000000..92d635d2f3d5
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeGenericTypeArg.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TypeGenericTypeArg`.
+ */
+
+private import internal.TypeGenericTypeArgImpl
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeGenericArg
+
+/**
+ * A generic argument for a type that is a type.
+ */
+final class TypeGenericTypeArg = Impl::TypeGenericTypeArg;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeImplItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeImplItemCanonicalPath.qll
new file mode 100644
index 000000000000..6249b275889e
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeImplItemCanonicalPath.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TypeImplItemCanonicalPath`.
+ */
+
+private import internal.TypeImplItemCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+
+/**
+ * A canonical path for an item defined in a type impl.
+ */
+final class TypeImplItemCanonicalPath = Impl::TypeImplItemCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeItemCanonicalPath.qll
new file mode 100644
index 000000000000..66239b547207
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/TypeItemCanonicalPath.qll
@@ -0,0 +1,13 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the public class `TypeItemCanonicalPath`.
+ */
+
+private import internal.TypeItemCanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+
+/**
+ * A canonical path for an item defined in a type or trait.
+ */
+final class TypeItemCanonicalPath = Impl::TypeItemCanonicalPath;
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..d95e3e62f092
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `BuiltinTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `BuiltinTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBuiltinTypeCanonicalPath(Raw::BuiltinTypeCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathImpl.qll
new file mode 100644
index 000000000000..03413dd1c1a2
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/BuiltinTypeCanonicalPathImpl.qll
@@ -0,0 +1,19 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BuiltinTypeCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.BuiltinTypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `BuiltinTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  /**
+   * A canonical path for a builtin type.
+   */
+  class BuiltinTypeCanonicalPath extends Generated::BuiltinTypeCanonicalPath { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathElementImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathElementImpl.qll
new file mode 100644
index 000000000000..0e1fe3794100
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathElementImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `CanonicalPathElement`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.CanonicalPathElement
+
+/**
+ * INTERNAL: This module contains the customizable definition of `CanonicalPathElement` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * The base class for all elements in a canonical path.
+   */
+  class CanonicalPathElement extends Generated::CanonicalPathElement {
+    override string toString() { result = "?" }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathImpl.qll
new file mode 100644
index 000000000000..445cf1037417
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/CanonicalPathImpl.qll
@@ -0,0 +1,35 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `CanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.CanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `CanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * The base class for all canonical paths that can be the result of a path resolution.
+   */
+  class CanonicalPath extends Generated::CanonicalPath {
+    /**
+     * If this canonical path is of the form `crate::mod1::mod2::Type::name`, then this predicate
+     * splits it into its components `crate::mod1::mod2`, `Type` and `name`. This applies to
+     * type, trait and type impl items, not to module items (see `hasStandardPath/2`) nor to
+     * trait impl items (TODO).
+     */
+    predicate hasStandardPath(string namespace, string type, string name) { none() }
+
+    /**
+     * If this canonical path is of the form `crate::mod1::mod2::name`, then this predicate
+     * splits it into its components `crate::mod1::mod2` and `name`. This applies to
+     * module items, but not to type, trait and type impl items (see `hasStandardPath/3`) nor to
+     * trait impl items (TODO).
+     */
+    predicate hasStandardPath(string namespace, string name) { none() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..b67a9318b697
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `ConcreteTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `ConcreteTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructConcreteTypeCanonicalPath(Raw::ConcreteTypeCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathImpl.qll
new file mode 100644
index 000000000000..e803f16533b0
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConcreteTypeCanonicalPathImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ConcreteTypeCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.ConcreteTypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `ConcreteTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A canonical path for an actual type.
+   */
+  class ConcreteTypeCanonicalPath extends Generated::ConcreteTypeCanonicalPath {
+    override string toString() { result = this.getPath().toAbbreviatedString() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgConstructor.qll
new file mode 100644
index 000000000000..81311f5f353a
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `ConstGenericTypeArg` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `ConstGenericTypeArg` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructConstGenericTypeArg(Raw::ConstGenericTypeArg id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgImpl.qll
new file mode 100644
index 000000000000..e980162c8559
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ConstGenericTypeArgImpl.qll
@@ -0,0 +1,23 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ConstGenericTypeArg`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.ConstGenericTypeArg
+
+/**
+ * INTERNAL: This module contains the customizable definition of `ConstGenericTypeArg` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A generic argument for a type that is a const.
+   */
+  class ConstGenericTypeArg extends Generated::ConstGenericTypeArg {
+    override string toString() { result = "const ?" }
+
+    override string toAbbreviatedString() { result = "?" }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..2c38d5dc76ea
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `DerivedTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `DerivedTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructDerivedTypeCanonicalPath(Raw::DerivedTypeCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathImpl.qll
new file mode 100644
index 000000000000..b68c963fc280
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathImpl.qll
@@ -0,0 +1,29 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `DerivedTypeCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.DerivedTypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `DerivedTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
+   */
+  class DerivedTypeCanonicalPath extends Generated::DerivedTypeCanonicalPath {
+    override string toString() { result = strictconcat(int i | | this.toStringPart(i) order by i) }
+
+    private string toStringPart(int index) {
+      exists(int j |
+        index = 2 * j and result = this.getModifier(j)
+        or
+        index = 2 * j + 1 and result = this.getBase(j).toAbbreviatedString()
+      )
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRefImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRefImpl.qll
new file mode 100644
index 000000000000..d169ce025b04
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRefImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `LangCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.LangCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `LangCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate in the Rust standard libraries.
+   */
+  class LangCrateRef extends Generated::LangCrateRef {
+    override string toString() { result = this.getName() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRootImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRootImpl.qll
new file mode 100644
index 000000000000..cecbb61ef4ae
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/LangCrateRootImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `LangCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.LangCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `LangCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate in the Rust standard libraries.
+   */
+  class LangCrateRef extends Generated::LangCrateRef {
+    override string toAbbreviatedString() { result = this.getName() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..5c63d76e8f8c
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `ModuleItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `ModuleItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructModuleItemCanonicalPath(Raw::ModuleItemCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathImpl.qll
new file mode 100644
index 000000000000..cfbf706793b5
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ModuleItemCanonicalPathImpl.qll
@@ -0,0 +1,27 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ModuleItemCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.ModuleItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `ModuleItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A canonical path for an item defined in a module.
+   */
+  class ModuleItemCanonicalPath extends Generated::ModuleItemCanonicalPath {
+    override string toString() {
+      result = this.getNamespace().toAbbreviatedString() + "::" + this.getName()
+    }
+
+    override predicate hasStandardPath(string namespace, string name) {
+      this.getName() = name and namespace = this.getNamespace().getNamespaceString()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceConstructor.qll
new file mode 100644
index 000000000000..c293665733e5
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `Namespace` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `Namespace` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructNamespace(Raw::Namespace id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceImpl.qll
new file mode 100644
index 000000000000..a3ea449660cf
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/NamespaceImpl.qll
@@ -0,0 +1,38 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `Namespace`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.Namespace
+
+/**
+ * INTERNAL: This module contains the customizable definition of `Namespace` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A namespace, comprised of a crate root and a possibly empty `::` separated module path.
+   */
+  class Namespace extends Generated::Namespace {
+    override string toString() {
+      exists(string root |
+        root = this.getRoot().toString() and
+        if this.getPath() = "" then result = root else result = root + "::" + this.getPath()
+      )
+    }
+
+    /**
+     * Returns a string representation of this namespace, with the root and path separated by `::`.
+     */
+    cached
+    string getNamespaceString() {
+      exists(string root, string path |
+        root = this.getRoot().toString() and
+        path = this.getPath() and
+        if path = "" then result = root else result = root + "::" + path
+      )
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..07d8877cf0b7
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `ParametrizedCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `ParametrizedCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructParametrizedCanonicalPath(Raw::ParametrizedCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathImpl.qll
new file mode 100644
index 000000000000..aef50a843c1f
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/ParametrizedCanonicalPathImpl.qll
@@ -0,0 +1,30 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ParametrizedCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.ParametrizedCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `ParametrizedCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  class ParametrizedCanonicalPath extends Generated::ParametrizedCanonicalPath {
+    override string toString() {
+      exists(string args |
+        (
+          if this.getNumberOfGenericArgs() > 0
+          then
+            args =
+              "<" +
+                strictconcat(int i | | this.getGenericArg(i).toAbbreviatedString(), ", " order by i)
+                + ">"
+          else args = ""
+        ) and
+        result = this.getBase().toAbbreviatedString() + args
+      )
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..6e80fa9b7788
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `PlaceholderTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `PlaceholderTypeCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructPlaceholderTypeCanonicalPath(Raw::PlaceholderTypeCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathImpl.qll
new file mode 100644
index 000000000000..e4081a6b4e60
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/PlaceholderTypeCanonicalPathImpl.qll
@@ -0,0 +1,23 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `PlaceholderTypeCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.PlaceholderTypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `PlaceholderTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A placeholder for a type parameter bound in an impl.
+   */
+  class PlaceholderTypeCanonicalPath extends Generated::PlaceholderTypeCanonicalPath {
+    override string toAbbreviatedString() { result = "_" }
+
+    override string toString() { result = "_" }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRefImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRefImpl.qll
new file mode 100644
index 000000000000..3c84b94f0e74
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRefImpl.qll
@@ -0,0 +1,25 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `RepoCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.RepoCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `RepoCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate in the repository.
+   */
+  class RepoCrateRef extends Generated::RepoCrateRef {
+    override string toString() {
+      result = this.getName()
+      or
+      not this.hasName() and result = "?"
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRootImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRootImpl.qll
new file mode 100644
index 000000000000..9e3fdce65ae0
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RepoCrateRootImpl.qll
@@ -0,0 +1,25 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `RepoCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.RepoCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `RepoCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate in the repository.
+   */
+  class RepoCrateRef extends Generated::RepoCrateRef {
+    override string toAbbreviatedString() {
+      result = this.getName()
+      or
+      not this.hasName() and result = "<unnamed>"
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRefImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRefImpl.qll
new file mode 100644
index 000000000000..919d3a5b02a4
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRefImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `RustcCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.RustcCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `RustcCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate provided by rustc. TODO: understand where these come from.
+   */
+  class RustcCrateRef extends Generated::RustcCrateRef {
+    override string toString() { result = this.getName() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRootImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRootImpl.qll
new file mode 100644
index 000000000000..49bdff234cfa
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/RustcCrateRootImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `RustcCrateRef`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.RustcCrateRef
+
+/**
+ * INTERNAL: This module contains the customizable definition of `RustcCrateRef` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A reference to a crate provided by rustc. TODO: understand where these come from.
+   */
+  class RustcCrateRef extends Generated::RustcCrateRef {
+    override string toAbbreviatedString() { result = this.getName() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..e783b8e94cef
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `TraitImplItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `TraitImplItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructTraitImplItemCanonicalPath(Raw::TraitImplItemCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathImpl.qll
new file mode 100644
index 000000000000..af71d5abb7e3
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TraitImplItemCanonicalPathImpl.qll
@@ -0,0 +1,25 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TraitImplItemCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TraitImplItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TraitImplItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A canonical path for an item defined in a trait impl.
+   */
+  class TraitImplItemCanonicalPath extends Generated::TraitImplItemCanonicalPath {
+    override string toString() {
+      result =
+        "<" + this.getTypePath().toAbbreviatedString() + " as " +
+          this.getTraitPath().toAbbreviatedString() + ">::" + this.getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeCanonicalPathImpl.qll
new file mode 100644
index 000000000000..9e8993748f55
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeCanonicalPathImpl.qll
@@ -0,0 +1,19 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TypeCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  /**
+   * The base for canonical paths for types.
+   */
+  class TypeCanonicalPath extends Generated::TypeCanonicalPath { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericArgImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericArgImpl.qll
new file mode 100644
index 000000000000..5b135de42f1c
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericArgImpl.qll
@@ -0,0 +1,19 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TypeGenericArg`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TypeGenericArg
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TypeGenericArg` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A generic argument for a type.
+   */
+  class TypeGenericArg extends Generated::TypeGenericArg { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgConstructor.qll
new file mode 100644
index 000000000000..dffef289c653
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `TypeGenericTypeArg` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `TypeGenericTypeArg` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructTypeGenericTypeArg(Raw::TypeGenericTypeArg id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgImpl.qll
new file mode 100644
index 000000000000..9be1b5edf2ae
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeGenericTypeArgImpl.qll
@@ -0,0 +1,21 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TypeGenericTypeArg`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TypeGenericTypeArg
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TypeGenericTypeArg` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A generic argument for a type that is a type.
+   */
+  class TypeGenericTypeArg extends Generated::TypeGenericTypeArg {
+    override string toString() { result = this.getPath().toAbbreviatedString() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..a6a539fa4737
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `TypeImplItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `TypeImplItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructTypeImplItemCanonicalPath(Raw::TypeImplItemCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathImpl.qll
new file mode 100644
index 000000000000..6e7a1dda08be
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeImplItemCanonicalPathImpl.qll
@@ -0,0 +1,27 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TypeImplItemCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TypeImplItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TypeImplItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A canonical path for an item defined in a type impl.
+   */
+  class TypeImplItemCanonicalPath extends Generated::TypeImplItemCanonicalPath {
+    override string toString() {
+      result = "<" + this.getParent().toAbbreviatedString() + ">::" + this.getName()
+    }
+
+    override predicate hasStandardPath(string namespace, string type, string name) {
+      this.getName() = name and this.getParent().hasStandardPath(namespace, type)
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathConstructor.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathConstructor.qll
new file mode 100644
index 000000000000..a5e58159db5c
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathConstructor.qll
@@ -0,0 +1,14 @@
+// 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
+ *  `TypeItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.Raw
+
+/**
+ *  The characteristic predicate of `TypeItemCanonicalPath` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructTypeItemCanonicalPath(Raw::TypeItemCanonicalPath id) { any() }
diff --git a/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathImpl.qll b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathImpl.qll
new file mode 100644
index 000000000000..e99c01b14696
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/canonical_paths/internal/TypeItemCanonicalPathImpl.qll
@@ -0,0 +1,27 @@
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `TypeItemCanonicalPath`.
+ *
+ * INTERNAL: Do not use.
+ */
+
+private import codeql.rust.elements.internal.generated.canonical_paths.TypeItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the customizable definition of `TypeItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
+  /**
+   * A canonical path for an item defined in a type or trait.
+   */
+  class TypeItemCanonicalPath extends Generated::TypeItemCanonicalPath {
+    override string toString() {
+      result = this.getParent().toAbbreviatedString() + "::" + this.getName()
+    }
+
+    override predicate hasStandardPath(string namespace, string type, string name) {
+      this.getName() = name and this.getParent().hasStandardPath(namespace, type)
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/AddressableImpl.qll b/rust/ql/lib/codeql/rust/elements/internal/AddressableImpl.qll
index b3fe47b294a2..ebf0230ad797 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/AddressableImpl.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/AddressableImpl.qll
@@ -1,4 +1,3 @@
-// generated by codegen, remove this comment if you wish to edit this file
 /**
  * This module provides a hand-modifiable wrapper around the generated class `Addressable`.
  *
@@ -12,10 +11,25 @@ private import codeql.rust.elements.internal.generated.Addressable
  * be referenced directly.
  */
 module Impl {
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
    * Something that can be addressed by a path.
    *
    * TODO: This does not yet include all possible cases.
    */
-  class Addressable extends Generated::Addressable { }
+  class Addressable extends Generated::Addressable {
+    /**
+     * Splits the standard path into its components (see `CanonicalPath::hasStandardPath/3`).
+     */
+    predicate hasStandardPath(string namespace, string type, string name) {
+      this.getCanonicalPath().hasStandardPath(namespace, type, name)
+    }
+
+    /**
+     * Splits the standard path into its components (see `CanonicalPath::hasStandardPath/2`).
+     */
+    predicate hasStandardPath(string namespace, string name) {
+      this.getCanonicalPath().hasStandardPath(namespace, name)
+    }
+  }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/ResolvableImpl.qll b/rust/ql/lib/codeql/rust/elements/internal/ResolvableImpl.qll
index 86304cd23de3..af946a987d5b 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/ResolvableImpl.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/ResolvableImpl.qll
@@ -20,16 +20,23 @@ module Impl {
   class Resolvable extends Generated::Resolvable {
     /**
      * Holds if this resolvable and the item `i` resolves to the same canonical
-     * path in the same crate
+     * path
      */
     pragma[nomagic]
-    predicate resolvesAsItem(Item i) {
-      this.getResolvedPath() = i.getExtendedCanonicalPath() and
-      (
-        this.getResolvedCrateOrigin() = i.getCrateOrigin()
-        or
-        not this.hasResolvedCrateOrigin() and not i.hasCrateOrigin()
-      )
+    predicate resolvesAsItem(Item i) { this.getResolvedCanonicalPath() = i.getCanonicalPath() }
+
+    /**
+     * Splits the standard path this resolves into into its components (see `CanonicalPath::hasStandardPath/3`).
+     */
+    predicate resolvesToStandardPath(string namespace, string type, string name) {
+      this.getResolvedCanonicalPath().hasStandardPath(namespace, type, name)
+    }
+
+    /**
+     * Splits the standard path into its components (see `CanonicalPath::hasStandardPath/2`).
+     */
+    predicate resolvesToStandardPath(string namespace, string name) {
+      this.getResolvedCanonicalPath().hasStandardPath(namespace, name)
     }
   }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/VariantImpl.qll b/rust/ql/lib/codeql/rust/elements/internal/VariantImpl.qll
index b4f1f326af03..3fd5ea32dfb1 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/VariantImpl.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/VariantImpl.qll
@@ -5,6 +5,7 @@
  */
 
 private import codeql.rust.elements.internal.generated.Variant
+private import codeql.rust.elements.Enum
 
 /**
  * INTERNAL: This module contains the customizable definition of `Variant` and should not
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Addressable.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Addressable.qll
index 9d4ba1e976a3..907fcd7d0049 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/Addressable.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Addressable.qll
@@ -7,6 +7,7 @@
 private import codeql.rust.elements.internal.generated.Synth
 private import codeql.rust.elements.internal.generated.Raw
 import codeql.rust.elements.internal.AstNodeImpl::Impl as AstNodeImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
 
 /**
  * INTERNAL: This module contains the fully generated definition of `Addressable` and should not
@@ -22,37 +23,21 @@ module Generated {
    */
   class Addressable extends Synth::TAddressable, AstNodeImpl::AstNode {
     /**
-     * Gets the extended canonical path of this addressable, if it exists.
+     * Gets the canonical path of this addressable, if it exists.
      *
-     * Either a canonical path (see https://doc.rust-lang.org/reference/paths.html#canonical-paths),
-     * or `{<block id>}::name` for addressable items defined in an anonymous block (and only
-     * addressable there-in).
      * INTERNAL: Do not use.
      */
-    string getExtendedCanonicalPath() {
-      result = Synth::convertAddressableToRaw(this).(Raw::Addressable).getExtendedCanonicalPath()
+    CanonicalPath getCanonicalPath() {
+      result =
+        Synth::convertCanonicalPathFromRaw(Synth::convertAddressableToRaw(this)
+              .(Raw::Addressable)
+              .getCanonicalPath())
     }
 
     /**
-     * Holds if `getExtendedCanonicalPath()` exists.
+     * Holds if `getCanonicalPath()` exists.
      * INTERNAL: Do not use.
      */
-    final predicate hasExtendedCanonicalPath() { exists(this.getExtendedCanonicalPath()) }
-
-    /**
-     * Gets the crate origin of this addressable, if it exists.
-     *
-     * One of `rustc:<name>`, `repo:<repository>:<name>` or `lang:<name>`.
-     * INTERNAL: Do not use.
-     */
-    string getCrateOrigin() {
-      result = Synth::convertAddressableToRaw(this).(Raw::Addressable).getCrateOrigin()
-    }
-
-    /**
-     * Holds if `getCrateOrigin()` exists.
-     * INTERNAL: Do not use.
-     */
-    final predicate hasCrateOrigin() { exists(this.getCrateOrigin()) }
+    final predicate hasCanonicalPath() { exists(this.getCanonicalPath()) }
   }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/ParentChild.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/ParentChild.qll
index 23b464bb895e..89649c307b5c 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/ParentChild.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/ParentChild.qll
@@ -3739,6 +3739,353 @@ private module Impl {
     )
   }
 
+  private Element getImmediateChildOfCanonicalPathElement(
+    CanonicalPathElement e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bElement, int n |
+      b = 0 and
+      bElement = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfElement(e, i, _)) | i) and
+      n = bElement and
+      (
+        none()
+        or
+        result = getImmediateChildOfElement(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfCanonicalPath(
+    CanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPathElement, int n |
+      b = 0 and
+      bCanonicalPathElement =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPathElement(e, i, _)) | i) and
+      n = bCanonicalPathElement and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPathElement(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfCrateRef(CrateRef e, int index, string partialPredicateCall) {
+    exists(int b, int bCanonicalPathElement, int n |
+      b = 0 and
+      bCanonicalPathElement =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPathElement(e, i, _)) | i) and
+      n = bCanonicalPathElement and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPathElement(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTypeGenericArg(
+    TypeGenericArg e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPathElement, int n |
+      b = 0 and
+      bCanonicalPathElement =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPathElement(e, i, _)) | i) and
+      n = bCanonicalPathElement and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPathElement(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfConstGenericTypeArg(
+    ConstGenericTypeArg e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeGenericArg, int n |
+      b = 0 and
+      bTypeGenericArg =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeGenericArg(e, i, _)) | i) and
+      n = bTypeGenericArg and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeGenericArg(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfLangCrateRef(
+    LangCrateRef e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCrateRef, int n |
+      b = 0 and
+      bCrateRef = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCrateRef(e, i, _)) | i) and
+      n = bCrateRef and
+      (
+        none()
+        or
+        result = getImmediateChildOfCrateRef(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfModuleItemCanonicalPath(
+    ModuleItemCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n, int nNamespace |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nNamespace = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getNamespace() and partialPredicateCall = "Namespace()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfNamespace(Namespace e, int index, string partialPredicateCall) {
+    exists(int b, int bCanonicalPath, int n, int nRoot |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nRoot = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getRoot() and partialPredicateCall = "Root()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfParametrizedCanonicalPath(
+    ParametrizedCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n, int nBase, int nGenericArg |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nBase = n + 1 and
+      nGenericArg = nBase + 1 + max(int i | i = -1 or exists(e.getGenericArg(i)) | i) and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getBase() and partialPredicateCall = "Base()"
+        or
+        result = e.getGenericArg(index - nBase) and
+        partialPredicateCall = "GenericArg(" + (index - nBase).toString() + ")"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfRepoCrateRef(
+    RepoCrateRef e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCrateRef, int n |
+      b = 0 and
+      bCrateRef = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCrateRef(e, i, _)) | i) and
+      n = bCrateRef and
+      (
+        none()
+        or
+        result = getImmediateChildOfCrateRef(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfRustcCrateRef(
+    RustcCrateRef e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCrateRef, int n |
+      b = 0 and
+      bCrateRef = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCrateRef(e, i, _)) | i) and
+      n = bCrateRef and
+      (
+        none()
+        or
+        result = getImmediateChildOfCrateRef(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTraitImplItemCanonicalPath(
+    TraitImplItemCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n, int nTypePath, int nTraitPath |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nTypePath = n + 1 and
+      nTraitPath = nTypePath + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getTypePath() and partialPredicateCall = "TypePath()"
+        or
+        index = nTypePath and result = e.getTraitPath() and partialPredicateCall = "TraitPath()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTypeCanonicalPath(
+    TypeCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTypeGenericTypeArg(
+    TypeGenericTypeArg e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeGenericArg, int n, int nPath |
+      b = 0 and
+      bTypeGenericArg =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeGenericArg(e, i, _)) | i) and
+      n = bTypeGenericArg and
+      nPath = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeGenericArg(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getPath() and partialPredicateCall = "Path()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTypeImplItemCanonicalPath(
+    TypeImplItemCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n, int nParent |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nParent = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getParent() and partialPredicateCall = "Parent()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfTypeItemCanonicalPath(
+    TypeItemCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bCanonicalPath, int n, int nParent |
+      b = 0 and
+      bCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfCanonicalPath(e, i, _)) | i) and
+      n = bCanonicalPath and
+      nParent = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getParent() and partialPredicateCall = "Parent()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfBuiltinTypeCanonicalPath(
+    BuiltinTypeCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeCanonicalPath, int n |
+      b = 0 and
+      bTypeCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeCanonicalPath(e, i, _)) | i) and
+      n = bTypeCanonicalPath and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeCanonicalPath(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
+  private Element getImmediateChildOfConcreteTypeCanonicalPath(
+    ConcreteTypeCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeCanonicalPath, int n, int nPath |
+      b = 0 and
+      bTypeCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeCanonicalPath(e, i, _)) | i) and
+      n = bTypeCanonicalPath and
+      nPath = n + 1 and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        index = n and result = e.getPath() and partialPredicateCall = "Path()"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfDerivedTypeCanonicalPath(
+    DerivedTypeCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeCanonicalPath, int n, int nBase |
+      b = 0 and
+      bTypeCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeCanonicalPath(e, i, _)) | i) and
+      n = bTypeCanonicalPath and
+      nBase = n + 1 + max(int i | i = -1 or exists(e.getBase(i)) | i) and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeCanonicalPath(e, index - b, partialPredicateCall)
+        or
+        result = e.getBase(index - n) and
+        partialPredicateCall = "Base(" + (index - n).toString() + ")"
+      )
+    )
+  }
+
+  private Element getImmediateChildOfPlaceholderTypeCanonicalPath(
+    PlaceholderTypeCanonicalPath e, int index, string partialPredicateCall
+  ) {
+    exists(int b, int bTypeCanonicalPath, int n |
+      b = 0 and
+      bTypeCanonicalPath =
+        b + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeCanonicalPath(e, i, _)) | i) and
+      n = bTypeCanonicalPath and
+      (
+        none()
+        or
+        result = getImmediateChildOfTypeCanonicalPath(e, index - b, partialPredicateCall)
+      )
+    )
+  }
+
   cached
   Element getImmediateChild(Element e, int index, string partialAccessor) {
     // why does this look more complicated than it should?
@@ -4044,6 +4391,36 @@ private module Impl {
     result = getImmediateChildOfLoopExpr(e, index, partialAccessor)
     or
     result = getImmediateChildOfWhileExpr(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfConstGenericTypeArg(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfLangCrateRef(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfModuleItemCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfNamespace(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfParametrizedCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfRepoCrateRef(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfRustcCrateRef(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfTraitImplItemCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfTypeGenericTypeArg(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfTypeImplItemCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfTypeItemCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfBuiltinTypeCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfConcreteTypeCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfDerivedTypeCanonicalPath(e, index, partialAccessor)
+    or
+    result = getImmediateChildOfPlaceholderTypeCanonicalPath(e, index, partialAccessor)
   }
 }
 
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll
index 5a32a8623bc1..1cbd2bd96819 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll
@@ -93,20 +93,9 @@ module Raw {
    */
   class Addressable extends @addressable, AstNode {
     /**
-     * Gets the extended canonical path of this addressable, if it exists.
-     *
-     * Either a canonical path (see https://doc.rust-lang.org/reference/paths.html#canonical-paths),
-     * or `{<block id>}::name` for addressable items defined in an anonymous block (and only
-     * addressable there-in).
+     * Gets the canonical path of this addressable, if it exists.
      */
-    string getExtendedCanonicalPath() { addressable_extended_canonical_paths(this, result) }
-
-    /**
-     * Gets the crate origin of this addressable, if it exists.
-     *
-     * One of `rustc:<name>`, `repo:<repository>:<name>` or `lang:<name>`.
-     */
-    string getCrateOrigin() { addressable_crate_origins(this, result) }
+    CanonicalPath getCanonicalPath() { addressable_canonical_paths(this, result) }
   }
 
   /**
@@ -831,14 +820,9 @@ module Raw {
    */
   class Resolvable extends @resolvable, AstNode {
     /**
-     * Gets the resolved path of this resolvable, if it exists.
-     */
-    string getResolvedPath() { resolvable_resolved_paths(this, result) }
-
-    /**
-     * Gets the resolved crate origin of this resolvable, if it exists.
+     * Gets the resolved canonical path of this resolvable, if it exists.
      */
-    string getResolvedCrateOrigin() { resolvable_resolved_crate_origins(this, result) }
+    CanonicalPath getResolvedCanonicalPath() { resolvable_resolved_canonical_paths(this, result) }
   }
 
   /**
@@ -3958,4 +3942,275 @@ module Raw {
      */
     Expr getCondition() { while_expr_conditions(this, result) }
   }
+
+  /**
+   * INTERNAL: Do not use.
+   * The base class for all elements in a canonical path.
+   */
+  class CanonicalPathElement extends @canonical_path_element, Element { }
+
+  /**
+   * INTERNAL: Do not use.
+   * The base class for all canonical paths that can be the result of a path resolution.
+   */
+  class CanonicalPath extends @canonical_path, CanonicalPathElement { }
+
+  /**
+   * INTERNAL: Do not use.
+   * The base class for all crate references.
+   */
+  class CrateRef extends @crate_ref, CanonicalPathElement { }
+
+  /**
+   * INTERNAL: Do not use.
+   * A generic argument for a type.
+   */
+  class TypeGenericArg extends @type_generic_arg, CanonicalPathElement { }
+
+  /**
+   * INTERNAL: Do not use.
+   * A generic argument for a type that is a const.
+   */
+  class ConstGenericTypeArg extends @const_generic_type_arg, TypeGenericArg {
+    override string toString() { result = "ConstGenericTypeArg" }
+
+    /**
+     * Gets the value of this const generic type argument.
+     */
+    string getValue() { const_generic_type_args(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A reference to a crate in the Rust standard libraries.
+   */
+  class LangCrateRef extends @lang_crate_ref, CrateRef {
+    override string toString() { result = "LangCrateRef" }
+
+    /**
+     * Gets the name of this lang crate reference.
+     */
+    string getName() { lang_crate_refs(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for an item defined in a module.
+   */
+  class ModuleItemCanonicalPath extends @module_item_canonical_path, CanonicalPath {
+    override string toString() { result = "ModuleItemCanonicalPath" }
+
+    /**
+     * Gets the namespace of this module item canonical path.
+     */
+    Namespace getNamespace() { module_item_canonical_paths(this, result, _) }
+
+    /**
+     * Gets the name of this module item canonical path.
+     */
+    string getName() { module_item_canonical_paths(this, _, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A namespace, comprised of a crate root and a possibly empty `::` separated module path.
+   */
+  class Namespace extends @namespace, CanonicalPath {
+    override string toString() { result = "Namespace" }
+
+    /**
+     * Gets the root of this namespace.
+     */
+    CrateRef getRoot() { namespaces(this, result, _) }
+
+    /**
+     * Gets the path of this namespace.
+     */
+    string getPath() { namespaces(this, _, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   */
+  class ParametrizedCanonicalPath extends @parametrized_canonical_path, CanonicalPath {
+    override string toString() { result = "ParametrizedCanonicalPath" }
+
+    /**
+     * Gets the base of this parametrized canonical path.
+     */
+    ModuleItemCanonicalPath getBase() { parametrized_canonical_paths(this, result) }
+
+    /**
+     * Gets the `index`th generic argument of this parametrized canonical path (0-based).
+     */
+    TypeGenericArg getGenericArg(int index) {
+      parametrized_canonical_path_generic_args(this, index, result)
+    }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A reference to a crate in the repository.
+   */
+  class RepoCrateRef extends @repo_crate_ref, CrateRef {
+    override string toString() { result = "RepoCrateRef" }
+
+    /**
+     * Gets the name of this repo crate reference, if it exists.
+     */
+    string getName() { repo_crate_ref_names(this, result) }
+
+    /**
+     * Gets the repo of this repo crate reference, if it exists.
+     */
+    string getRepo() { repo_crate_ref_repos(this, result) }
+
+    /**
+     * Gets the source of this repo crate reference.
+     */
+    File getSource() { repo_crate_refs(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A reference to a crate provided by rustc. TODO: understand where these come from.
+   */
+  class RustcCrateRef extends @rustc_crate_ref, CrateRef {
+    override string toString() { result = "RustcCrateRef" }
+
+    /**
+     * Gets the name of this rustc crate reference.
+     */
+    string getName() { rustc_crate_refs(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for an item defined in a trait impl.
+   */
+  class TraitImplItemCanonicalPath extends @trait_impl_item_canonical_path, CanonicalPath {
+    override string toString() { result = "TraitImplItemCanonicalPath" }
+
+    /**
+     * Gets the type path of this trait impl item canonical path.
+     */
+    TypeCanonicalPath getTypePath() { trait_impl_item_canonical_paths(this, result, _, _) }
+
+    /**
+     * Gets the trait path of this trait impl item canonical path.
+     */
+    ParametrizedCanonicalPath getTraitPath() { trait_impl_item_canonical_paths(this, _, result, _) }
+
+    /**
+     * Gets the name of this trait impl item canonical path.
+     */
+    string getName() { trait_impl_item_canonical_paths(this, _, _, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * The base for canonical paths for types.
+   */
+  class TypeCanonicalPath extends @type_canonical_path, CanonicalPath { }
+
+  /**
+   * INTERNAL: Do not use.
+   * A generic argument for a type that is a type.
+   */
+  class TypeGenericTypeArg extends @type_generic_type_arg, TypeGenericArg {
+    override string toString() { result = "TypeGenericTypeArg" }
+
+    /**
+     * Gets the path of this type generic type argument.
+     */
+    TypeCanonicalPath getPath() { type_generic_type_args(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for an item defined in a type impl.
+   */
+  class TypeImplItemCanonicalPath extends @type_impl_item_canonical_path, CanonicalPath {
+    override string toString() { result = "TypeImplItemCanonicalPath" }
+
+    /**
+     * Gets the parent of this type impl item canonical path.
+     */
+    ModuleItemCanonicalPath getParent() { type_impl_item_canonical_paths(this, result, _) }
+
+    /**
+     * Gets the name of this type impl item canonical path.
+     */
+    string getName() { type_impl_item_canonical_paths(this, _, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for an item defined in a type or trait.
+   */
+  class TypeItemCanonicalPath extends @type_item_canonical_path, CanonicalPath {
+    override string toString() { result = "TypeItemCanonicalPath" }
+
+    /**
+     * Gets the parent of this type item canonical path.
+     */
+    ModuleItemCanonicalPath getParent() { type_item_canonical_paths(this, result, _) }
+
+    /**
+     * Gets the name of this type item canonical path.
+     */
+    string getName() { type_item_canonical_paths(this, _, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for a builtin type.
+   */
+  class BuiltinTypeCanonicalPath extends @builtin_type_canonical_path, TypeCanonicalPath {
+    override string toString() { result = "BuiltinTypeCanonicalPath" }
+
+    /**
+     * Gets the name of this builtin type canonical path.
+     */
+    string getName() { builtin_type_canonical_paths(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A canonical path for an actual type.
+   */
+  class ConcreteTypeCanonicalPath extends @concrete_type_canonical_path, TypeCanonicalPath {
+    override string toString() { result = "ConcreteTypeCanonicalPath" }
+
+    /**
+     * Gets the path of this concrete type canonical path.
+     */
+    ParametrizedCanonicalPath getPath() { concrete_type_canonical_paths(this, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
+   */
+  class DerivedTypeCanonicalPath extends @derived_type_canonical_path, TypeCanonicalPath {
+    override string toString() { result = "DerivedTypeCanonicalPath" }
+
+    /**
+     * Gets the `index`th modifier of this derived type canonical path (0-based).
+     */
+    string getModifier(int index) { derived_type_canonical_path_modifiers(this, index, result) }
+
+    /**
+     * Gets the `index`th base of this derived type canonical path (0-based).
+     */
+    TypeCanonicalPath getBase(int index) { derived_type_canonical_path_bases(this, index, result) }
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * A placeholder for a type parameter bound in an impl.
+   */
+  class PlaceholderTypeCanonicalPath extends @placeholder_type_canonical_path, TypeCanonicalPath {
+    override string toString() { result = "PlaceholderTypeCanonicalPath" }
+  }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Resolvable.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Resolvable.qll
index fb0d7975cf9b..16e2b85195e5 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/Resolvable.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Resolvable.qll
@@ -7,6 +7,7 @@
 private import codeql.rust.elements.internal.generated.Synth
 private import codeql.rust.elements.internal.generated.Raw
 import codeql.rust.elements.internal.AstNodeImpl::Impl as AstNodeImpl
+import codeql.rust.elements.canonical_paths.CanonicalPath
 
 /**
  * INTERNAL: This module contains the fully generated definition of `Resolvable` and should not
@@ -20,33 +21,21 @@ module Generated {
    */
   class Resolvable extends Synth::TResolvable, AstNodeImpl::AstNode {
     /**
-     * Gets the resolved path of this resolvable, if it exists.
+     * Gets the resolved canonical path of this resolvable, if it exists.
      *
      * INTERNAL: Do not use.
      */
-    string getResolvedPath() {
-      result = Synth::convertResolvableToRaw(this).(Raw::Resolvable).getResolvedPath()
+    CanonicalPath getResolvedCanonicalPath() {
+      result =
+        Synth::convertCanonicalPathFromRaw(Synth::convertResolvableToRaw(this)
+              .(Raw::Resolvable)
+              .getResolvedCanonicalPath())
     }
 
     /**
-     * Holds if `getResolvedPath()` exists.
+     * Holds if `getResolvedCanonicalPath()` exists.
      * INTERNAL: Do not use.
      */
-    final predicate hasResolvedPath() { exists(this.getResolvedPath()) }
-
-    /**
-     * Gets the resolved crate origin of this resolvable, if it exists.
-     *
-     * INTERNAL: Do not use.
-     */
-    string getResolvedCrateOrigin() {
-      result = Synth::convertResolvableToRaw(this).(Raw::Resolvable).getResolvedCrateOrigin()
-    }
-
-    /**
-     * Holds if `getResolvedCrateOrigin()` exists.
-     * INTERNAL: Do not use.
-     */
-    final predicate hasResolvedCrateOrigin() { exists(this.getResolvedCrateOrigin()) }
+    final predicate hasResolvedCanonicalPath() { exists(this.getResolvedCanonicalPath()) }
   }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Synth.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Synth.qll
index 02ce677071e5..9960a3a72072 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/Synth.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Synth.qll
@@ -621,7 +621,83 @@ module Synth {
     /**
      * INTERNAL: Do not use.
      */
-    TYieldExpr(Raw::YieldExpr id) { constructYieldExpr(id) }
+    TYieldExpr(Raw::YieldExpr id) { constructYieldExpr(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TBuiltinTypeCanonicalPath(Raw::BuiltinTypeCanonicalPath id) {
+      constructBuiltinTypeCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TConcreteTypeCanonicalPath(Raw::ConcreteTypeCanonicalPath id) {
+      constructConcreteTypeCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TConstGenericTypeArg(Raw::ConstGenericTypeArg id) { constructConstGenericTypeArg(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TDerivedTypeCanonicalPath(Raw::DerivedTypeCanonicalPath id) {
+      constructDerivedTypeCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TLangCrateRef(Raw::LangCrateRef id) { constructLangCrateRef(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TModuleItemCanonicalPath(Raw::ModuleItemCanonicalPath id) {
+      constructModuleItemCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TNamespace(Raw::Namespace id) { constructNamespace(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TParametrizedCanonicalPath(Raw::ParametrizedCanonicalPath id) {
+      constructParametrizedCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TPlaceholderTypeCanonicalPath(Raw::PlaceholderTypeCanonicalPath id) {
+      constructPlaceholderTypeCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TRepoCrateRef(Raw::RepoCrateRef id) { constructRepoCrateRef(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TRustcCrateRef(Raw::RustcCrateRef id) { constructRustcCrateRef(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TTraitImplItemCanonicalPath(Raw::TraitImplItemCanonicalPath id) {
+      constructTraitImplItemCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TTypeGenericTypeArg(Raw::TypeGenericTypeArg id) { constructTypeGenericTypeArg(id) } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TTypeImplItemCanonicalPath(Raw::TypeImplItemCanonicalPath id) {
+      constructTypeImplItemCanonicalPath(id)
+    } or
+    /**
+     * INTERNAL: Do not use.
+     */
+    TTypeItemCanonicalPath(Raw::TypeItemCanonicalPath id) { constructTypeItemCanonicalPath(id) }
 
   /**
    * INTERNAL: Do not use.
@@ -768,6 +844,36 @@ module Synth {
    */
   class TUnextracted = TMissing or TUnimplemented;
 
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TCanonicalPath =
+    TModuleItemCanonicalPath or TNamespace or TParametrizedCanonicalPath or
+        TTraitImplItemCanonicalPath or TTypeCanonicalPath or TTypeImplItemCanonicalPath or
+        TTypeItemCanonicalPath;
+
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TCanonicalPathElement = TCanonicalPath or TCrateRef or TTypeGenericArg;
+
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TCrateRef = TLangCrateRef or TRepoCrateRef or TRustcCrateRef;
+
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TTypeCanonicalPath =
+    TBuiltinTypeCanonicalPath or TConcreteTypeCanonicalPath or TDerivedTypeCanonicalPath or
+        TPlaceholderTypeCanonicalPath;
+
+  /**
+   * INTERNAL: Do not use.
+   */
+  class TTypeGenericArg = TConstGenericTypeArg or TTypeGenericTypeArg;
+
   /**
    * INTERNAL: Do not use.
    * Converts a raw element to a synthesized `TAbi`, if possible.
@@ -1678,6 +1784,118 @@ module Synth {
    */
   TYieldExpr convertYieldExprFromRaw(Raw::Element e) { result = TYieldExpr(e) }
 
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TBuiltinTypeCanonicalPath`, if possible.
+   */
+  TBuiltinTypeCanonicalPath convertBuiltinTypeCanonicalPathFromRaw(Raw::Element e) {
+    result = TBuiltinTypeCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TConcreteTypeCanonicalPath`, if possible.
+   */
+  TConcreteTypeCanonicalPath convertConcreteTypeCanonicalPathFromRaw(Raw::Element e) {
+    result = TConcreteTypeCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TConstGenericTypeArg`, if possible.
+   */
+  TConstGenericTypeArg convertConstGenericTypeArgFromRaw(Raw::Element e) {
+    result = TConstGenericTypeArg(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TDerivedTypeCanonicalPath`, if possible.
+   */
+  TDerivedTypeCanonicalPath convertDerivedTypeCanonicalPathFromRaw(Raw::Element e) {
+    result = TDerivedTypeCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TLangCrateRef`, if possible.
+   */
+  TLangCrateRef convertLangCrateRefFromRaw(Raw::Element e) { result = TLangCrateRef(e) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TModuleItemCanonicalPath`, if possible.
+   */
+  TModuleItemCanonicalPath convertModuleItemCanonicalPathFromRaw(Raw::Element e) {
+    result = TModuleItemCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TNamespace`, if possible.
+   */
+  TNamespace convertNamespaceFromRaw(Raw::Element e) { result = TNamespace(e) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TParametrizedCanonicalPath`, if possible.
+   */
+  TParametrizedCanonicalPath convertParametrizedCanonicalPathFromRaw(Raw::Element e) {
+    result = TParametrizedCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TPlaceholderTypeCanonicalPath`, if possible.
+   */
+  TPlaceholderTypeCanonicalPath convertPlaceholderTypeCanonicalPathFromRaw(Raw::Element e) {
+    result = TPlaceholderTypeCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TRepoCrateRef`, if possible.
+   */
+  TRepoCrateRef convertRepoCrateRefFromRaw(Raw::Element e) { result = TRepoCrateRef(e) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TRustcCrateRef`, if possible.
+   */
+  TRustcCrateRef convertRustcCrateRefFromRaw(Raw::Element e) { result = TRustcCrateRef(e) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TTraitImplItemCanonicalPath`, if possible.
+   */
+  TTraitImplItemCanonicalPath convertTraitImplItemCanonicalPathFromRaw(Raw::Element e) {
+    result = TTraitImplItemCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TTypeGenericTypeArg`, if possible.
+   */
+  TTypeGenericTypeArg convertTypeGenericTypeArgFromRaw(Raw::Element e) {
+    result = TTypeGenericTypeArg(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TTypeImplItemCanonicalPath`, if possible.
+   */
+  TTypeImplItemCanonicalPath convertTypeImplItemCanonicalPathFromRaw(Raw::Element e) {
+    result = TTypeImplItemCanonicalPath(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw element to a synthesized `TTypeItemCanonicalPath`, if possible.
+   */
+  TTypeItemCanonicalPath convertTypeItemCanonicalPathFromRaw(Raw::Element e) {
+    result = TTypeItemCanonicalPath(e)
+  }
+
   /**
    * INTERNAL: Do not use.
    * Converts a raw DB element to a synthesized `TAddressable`, if possible.
@@ -1859,6 +2077,8 @@ module Synth {
    * Converts a raw DB element to a synthesized `TElement`, if possible.
    */
   TElement convertElementFromRaw(Raw::Element e) {
+    result = convertCanonicalPathElementFromRaw(e)
+    or
     result = convertExtractorStepFromRaw(e)
     or
     result = convertLocatableFromRaw(e)
@@ -2208,6 +2428,74 @@ module Synth {
     result = convertUnimplementedFromRaw(e)
   }
 
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TCanonicalPath`, if possible.
+   */
+  TCanonicalPath convertCanonicalPathFromRaw(Raw::Element e) {
+    result = convertModuleItemCanonicalPathFromRaw(e)
+    or
+    result = convertNamespaceFromRaw(e)
+    or
+    result = convertParametrizedCanonicalPathFromRaw(e)
+    or
+    result = convertTraitImplItemCanonicalPathFromRaw(e)
+    or
+    result = convertTypeCanonicalPathFromRaw(e)
+    or
+    result = convertTypeImplItemCanonicalPathFromRaw(e)
+    or
+    result = convertTypeItemCanonicalPathFromRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TCanonicalPathElement`, if possible.
+   */
+  TCanonicalPathElement convertCanonicalPathElementFromRaw(Raw::Element e) {
+    result = convertCanonicalPathFromRaw(e)
+    or
+    result = convertCrateRefFromRaw(e)
+    or
+    result = convertTypeGenericArgFromRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TCrateRef`, if possible.
+   */
+  TCrateRef convertCrateRefFromRaw(Raw::Element e) {
+    result = convertLangCrateRefFromRaw(e)
+    or
+    result = convertRepoCrateRefFromRaw(e)
+    or
+    result = convertRustcCrateRefFromRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TTypeCanonicalPath`, if possible.
+   */
+  TTypeCanonicalPath convertTypeCanonicalPathFromRaw(Raw::Element e) {
+    result = convertBuiltinTypeCanonicalPathFromRaw(e)
+    or
+    result = convertConcreteTypeCanonicalPathFromRaw(e)
+    or
+    result = convertDerivedTypeCanonicalPathFromRaw(e)
+    or
+    result = convertPlaceholderTypeCanonicalPathFromRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a raw DB element to a synthesized `TTypeGenericArg`, if possible.
+   */
+  TTypeGenericArg convertTypeGenericArgFromRaw(Raw::Element e) {
+    result = convertConstGenericTypeArgFromRaw(e)
+    or
+    result = convertTypeGenericTypeArgFromRaw(e)
+  }
+
   /**
    * INTERNAL: Do not use.
    * Converts a synthesized `TAbi` to a raw DB element, if possible.
@@ -3116,6 +3404,118 @@ module Synth {
    */
   Raw::Element convertYieldExprToRaw(TYieldExpr e) { e = TYieldExpr(result) }
 
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TBuiltinTypeCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertBuiltinTypeCanonicalPathToRaw(TBuiltinTypeCanonicalPath e) {
+    e = TBuiltinTypeCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TConcreteTypeCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertConcreteTypeCanonicalPathToRaw(TConcreteTypeCanonicalPath e) {
+    e = TConcreteTypeCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TConstGenericTypeArg` to a raw DB element, if possible.
+   */
+  Raw::Element convertConstGenericTypeArgToRaw(TConstGenericTypeArg e) {
+    e = TConstGenericTypeArg(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TDerivedTypeCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertDerivedTypeCanonicalPathToRaw(TDerivedTypeCanonicalPath e) {
+    e = TDerivedTypeCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TLangCrateRef` to a raw DB element, if possible.
+   */
+  Raw::Element convertLangCrateRefToRaw(TLangCrateRef e) { e = TLangCrateRef(result) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TModuleItemCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertModuleItemCanonicalPathToRaw(TModuleItemCanonicalPath e) {
+    e = TModuleItemCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TNamespace` to a raw DB element, if possible.
+   */
+  Raw::Element convertNamespaceToRaw(TNamespace e) { e = TNamespace(result) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TParametrizedCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertParametrizedCanonicalPathToRaw(TParametrizedCanonicalPath e) {
+    e = TParametrizedCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TPlaceholderTypeCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertPlaceholderTypeCanonicalPathToRaw(TPlaceholderTypeCanonicalPath e) {
+    e = TPlaceholderTypeCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TRepoCrateRef` to a raw DB element, if possible.
+   */
+  Raw::Element convertRepoCrateRefToRaw(TRepoCrateRef e) { e = TRepoCrateRef(result) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TRustcCrateRef` to a raw DB element, if possible.
+   */
+  Raw::Element convertRustcCrateRefToRaw(TRustcCrateRef e) { e = TRustcCrateRef(result) }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTraitImplItemCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertTraitImplItemCanonicalPathToRaw(TTraitImplItemCanonicalPath e) {
+    e = TTraitImplItemCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeGenericTypeArg` to a raw DB element, if possible.
+   */
+  Raw::Element convertTypeGenericTypeArgToRaw(TTypeGenericTypeArg e) {
+    e = TTypeGenericTypeArg(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeImplItemCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertTypeImplItemCanonicalPathToRaw(TTypeImplItemCanonicalPath e) {
+    e = TTypeImplItemCanonicalPath(result)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeItemCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertTypeItemCanonicalPathToRaw(TTypeItemCanonicalPath e) {
+    e = TTypeItemCanonicalPath(result)
+  }
+
   /**
    * INTERNAL: Do not use.
    * Converts a synthesized `TAddressable` to a raw DB element, if possible.
@@ -3297,6 +3697,8 @@ module Synth {
    * Converts a synthesized `TElement` to a raw DB element, if possible.
    */
   Raw::Element convertElementToRaw(TElement e) {
+    result = convertCanonicalPathElementToRaw(e)
+    or
     result = convertExtractorStepToRaw(e)
     or
     result = convertLocatableToRaw(e)
@@ -3645,4 +4047,72 @@ module Synth {
     or
     result = convertUnimplementedToRaw(e)
   }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertCanonicalPathToRaw(TCanonicalPath e) {
+    result = convertModuleItemCanonicalPathToRaw(e)
+    or
+    result = convertNamespaceToRaw(e)
+    or
+    result = convertParametrizedCanonicalPathToRaw(e)
+    or
+    result = convertTraitImplItemCanonicalPathToRaw(e)
+    or
+    result = convertTypeCanonicalPathToRaw(e)
+    or
+    result = convertTypeImplItemCanonicalPathToRaw(e)
+    or
+    result = convertTypeItemCanonicalPathToRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TCanonicalPathElement` to a raw DB element, if possible.
+   */
+  Raw::Element convertCanonicalPathElementToRaw(TCanonicalPathElement e) {
+    result = convertCanonicalPathToRaw(e)
+    or
+    result = convertCrateRefToRaw(e)
+    or
+    result = convertTypeGenericArgToRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TCrateRef` to a raw DB element, if possible.
+   */
+  Raw::Element convertCrateRefToRaw(TCrateRef e) {
+    result = convertLangCrateRefToRaw(e)
+    or
+    result = convertRepoCrateRefToRaw(e)
+    or
+    result = convertRustcCrateRefToRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeCanonicalPath` to a raw DB element, if possible.
+   */
+  Raw::Element convertTypeCanonicalPathToRaw(TTypeCanonicalPath e) {
+    result = convertBuiltinTypeCanonicalPathToRaw(e)
+    or
+    result = convertConcreteTypeCanonicalPathToRaw(e)
+    or
+    result = convertDerivedTypeCanonicalPathToRaw(e)
+    or
+    result = convertPlaceholderTypeCanonicalPathToRaw(e)
+  }
+
+  /**
+   * INTERNAL: Do not use.
+   * Converts a synthesized `TTypeGenericArg` to a raw DB element, if possible.
+   */
+  Raw::Element convertTypeGenericArgToRaw(TTypeGenericArg e) {
+    result = convertConstGenericTypeArgToRaw(e)
+    or
+    result = convertTypeGenericTypeArgToRaw(e)
+  }
 }
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/SynthConstructors.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/SynthConstructors.qll
index 3b2a58083b14..98f06029d7f1 100644
--- a/rust/ql/lib/codeql/rust/elements/internal/generated/SynthConstructors.qll
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/SynthConstructors.qll
@@ -153,3 +153,18 @@ import codeql.rust.elements.internal.WhileExprConstructor
 import codeql.rust.elements.internal.WildcardPatConstructor
 import codeql.rust.elements.internal.YeetExprConstructor
 import codeql.rust.elements.internal.YieldExprConstructor
+import codeql.rust.elements.canonical_paths.internal.BuiltinTypeCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.ConcreteTypeCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.ConstGenericTypeArgConstructor
+import codeql.rust.elements.canonical_paths.internal.DerivedTypeCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.LangCrateRefConstructor
+import codeql.rust.elements.canonical_paths.internal.ModuleItemCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.NamespaceConstructor
+import codeql.rust.elements.canonical_paths.internal.ParametrizedCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.PlaceholderTypeCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.RepoCrateRefConstructor
+import codeql.rust.elements.canonical_paths.internal.RustcCrateRefConstructor
+import codeql.rust.elements.canonical_paths.internal.TraitImplItemCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.TypeGenericTypeArgConstructor
+import codeql.rust.elements.canonical_paths.internal.TypeImplItemCanonicalPathConstructor
+import codeql.rust.elements.canonical_paths.internal.TypeItemCanonicalPathConstructor
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/BuiltinTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/BuiltinTypeCanonicalPath.qll
new file mode 100644
index 000000000000..2681c9aa1601
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/BuiltinTypeCanonicalPath.qll
@@ -0,0 +1,34 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `BuiltinTypeCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.TypeCanonicalPathImpl::Impl as TypeCanonicalPathImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `BuiltinTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for a builtin type.
+   * INTERNAL: Do not reference the `Generated::BuiltinTypeCanonicalPath` class directly.
+   * Use the subclass `BuiltinTypeCanonicalPath`, where the following predicates are available.
+   */
+  class BuiltinTypeCanonicalPath extends Synth::TBuiltinTypeCanonicalPath,
+    TypeCanonicalPathImpl::TypeCanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "BuiltinTypeCanonicalPath" }
+
+    /**
+     * Gets the name of this builtin type canonical path.
+     */
+    string getName() {
+      result =
+        Synth::convertBuiltinTypeCanonicalPathToRaw(this).(Raw::BuiltinTypeCanonicalPath).getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPath.qll
new file mode 100644
index 000000000000..f2655e595de2
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPath.qll
@@ -0,0 +1,23 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `CanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathElementImpl::Impl as CanonicalPathElementImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `CanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * The base class for all canonical paths that can be the result of a path resolution.
+   * INTERNAL: Do not reference the `Generated::CanonicalPath` class directly.
+   * Use the subclass `CanonicalPath`, where the following predicates are available.
+   */
+  class CanonicalPath extends Synth::TCanonicalPath, CanonicalPathElementImpl::CanonicalPathElement {
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPathElement.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPathElement.qll
new file mode 100644
index 000000000000..6e51b0a6eb53
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/CanonicalPathElement.qll
@@ -0,0 +1,22 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `CanonicalPathElement`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.internal.ElementImpl::Impl as ElementImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `CanonicalPathElement` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * The base class for all elements in a canonical path.
+   * INTERNAL: Do not reference the `Generated::CanonicalPathElement` class directly.
+   * Use the subclass `CanonicalPathElement`, where the following predicates are available.
+   */
+  class CanonicalPathElement extends Synth::TCanonicalPathElement, ElementImpl::Element { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConcreteTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConcreteTypeCanonicalPath.qll
new file mode 100644
index 000000000000..f5231cd587ce
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConcreteTypeCanonicalPath.qll
@@ -0,0 +1,37 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `ConcreteTypeCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.ParametrizedCanonicalPath
+import codeql.rust.elements.canonical_paths.internal.TypeCanonicalPathImpl::Impl as TypeCanonicalPathImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `ConcreteTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for an actual type.
+   * INTERNAL: Do not reference the `Generated::ConcreteTypeCanonicalPath` class directly.
+   * Use the subclass `ConcreteTypeCanonicalPath`, where the following predicates are available.
+   */
+  class ConcreteTypeCanonicalPath extends Synth::TConcreteTypeCanonicalPath,
+    TypeCanonicalPathImpl::TypeCanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "ConcreteTypeCanonicalPath" }
+
+    /**
+     * Gets the path of this concrete type canonical path.
+     */
+    ParametrizedCanonicalPath getPath() {
+      result =
+        Synth::convertParametrizedCanonicalPathFromRaw(Synth::convertConcreteTypeCanonicalPathToRaw(this)
+              .(Raw::ConcreteTypeCanonicalPath)
+              .getPath())
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConstGenericTypeArg.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConstGenericTypeArg.qll
new file mode 100644
index 000000000000..518d188752ec
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ConstGenericTypeArg.qll
@@ -0,0 +1,31 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `ConstGenericTypeArg`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.TypeGenericArgImpl::Impl as TypeGenericArgImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `ConstGenericTypeArg` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A generic argument for a type that is a const.
+   * INTERNAL: Do not reference the `Generated::ConstGenericTypeArg` class directly.
+   * Use the subclass `ConstGenericTypeArg`, where the following predicates are available.
+   */
+  class ConstGenericTypeArg extends Synth::TConstGenericTypeArg, TypeGenericArgImpl::TypeGenericArg {
+    override string getAPrimaryQlClass() { result = "ConstGenericTypeArg" }
+
+    /**
+     * Gets the value of this const generic type argument.
+     */
+    string getValue() {
+      result = Synth::convertConstGenericTypeArgToRaw(this).(Raw::ConstGenericTypeArg).getValue()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/DerivedTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/DerivedTypeCanonicalPath.qll
new file mode 100644
index 000000000000..c325b887d866
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/DerivedTypeCanonicalPath.qll
@@ -0,0 +1,67 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `DerivedTypeCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+import codeql.rust.elements.canonical_paths.internal.TypeCanonicalPathImpl::Impl as TypeCanonicalPathImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `DerivedTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
+   * INTERNAL: Do not reference the `Generated::DerivedTypeCanonicalPath` class directly.
+   * Use the subclass `DerivedTypeCanonicalPath`, where the following predicates are available.
+   */
+  class DerivedTypeCanonicalPath extends Synth::TDerivedTypeCanonicalPath,
+    TypeCanonicalPathImpl::TypeCanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "DerivedTypeCanonicalPath" }
+
+    /**
+     * Gets the `index`th modifier of this derived type canonical path (0-based).
+     */
+    string getModifier(int index) {
+      result =
+        Synth::convertDerivedTypeCanonicalPathToRaw(this)
+            .(Raw::DerivedTypeCanonicalPath)
+            .getModifier(index)
+    }
+
+    /**
+     * Gets any of the modifiers of this derived type canonical path.
+     */
+    final string getAModifier() { result = this.getModifier(_) }
+
+    /**
+     * Gets the number of modifiers of this derived type canonical path.
+     */
+    final int getNumberOfModifiers() { result = count(int i | exists(this.getModifier(i))) }
+
+    /**
+     * Gets the `index`th base of this derived type canonical path (0-based).
+     */
+    TypeCanonicalPath getBase(int index) {
+      result =
+        Synth::convertTypeCanonicalPathFromRaw(Synth::convertDerivedTypeCanonicalPathToRaw(this)
+              .(Raw::DerivedTypeCanonicalPath)
+              .getBase(index))
+    }
+
+    /**
+     * Gets any of the bases of this derived type canonical path.
+     */
+    final TypeCanonicalPath getABase() { result = this.getBase(_) }
+
+    /**
+     * Gets the number of bases of this derived type canonical path.
+     */
+    final int getNumberOfBases() { result = count(int i | exists(this.getBase(i))) }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ModuleItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ModuleItemCanonicalPath.qll
new file mode 100644
index 000000000000..7c029f6cc3d6
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ModuleItemCanonicalPath.qll
@@ -0,0 +1,45 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `ModuleItemCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.Namespace
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `ModuleItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for an item defined in a module.
+   * INTERNAL: Do not reference the `Generated::ModuleItemCanonicalPath` class directly.
+   * Use the subclass `ModuleItemCanonicalPath`, where the following predicates are available.
+   */
+  class ModuleItemCanonicalPath extends Synth::TModuleItemCanonicalPath,
+    CanonicalPathImpl::CanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "ModuleItemCanonicalPath" }
+
+    /**
+     * Gets the namespace of this module item canonical path.
+     */
+    Namespace getNamespace() {
+      result =
+        Synth::convertNamespaceFromRaw(Synth::convertModuleItemCanonicalPathToRaw(this)
+              .(Raw::ModuleItemCanonicalPath)
+              .getNamespace())
+    }
+
+    /**
+     * Gets the name of this module item canonical path.
+     */
+    string getName() {
+      result =
+        Synth::convertModuleItemCanonicalPathToRaw(this).(Raw::ModuleItemCanonicalPath).getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/Namespace.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/Namespace.qll
new file mode 100644
index 000000000000..1d43e90ca876
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/Namespace.qll
@@ -0,0 +1,38 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `Namespace`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.CrateRef
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `Namespace` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A namespace, comprised of a crate root and a possibly empty `::` separated module path.
+   * INTERNAL: Do not reference the `Generated::Namespace` class directly.
+   * Use the subclass `Namespace`, where the following predicates are available.
+   */
+  class Namespace extends Synth::TNamespace, CanonicalPathImpl::CanonicalPath {
+    override string getAPrimaryQlClass() { result = "Namespace" }
+
+    /**
+     * Gets the root of this namespace.
+     */
+    CrateRef getRoot() {
+      result =
+        Synth::convertCrateRefFromRaw(Synth::convertNamespaceToRaw(this).(Raw::Namespace).getRoot())
+    }
+
+    /**
+     * Gets the path of this namespace.
+     */
+    string getPath() { result = Synth::convertNamespaceToRaw(this).(Raw::Namespace).getPath() }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ParametrizedCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ParametrizedCanonicalPath.qll
new file mode 100644
index 000000000000..861e95313b02
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/ParametrizedCanonicalPath.qll
@@ -0,0 +1,57 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `ParametrizedCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeGenericArg
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `ParametrizedCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * INTERNAL: Do not reference the `Generated::ParametrizedCanonicalPath` class directly.
+   * Use the subclass `ParametrizedCanonicalPath`, where the following predicates are available.
+   */
+  class ParametrizedCanonicalPath extends Synth::TParametrizedCanonicalPath,
+    CanonicalPathImpl::CanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "ParametrizedCanonicalPath" }
+
+    /**
+     * Gets the base of this parametrized canonical path.
+     */
+    ModuleItemCanonicalPath getBase() {
+      result =
+        Synth::convertModuleItemCanonicalPathFromRaw(Synth::convertParametrizedCanonicalPathToRaw(this)
+              .(Raw::ParametrizedCanonicalPath)
+              .getBase())
+    }
+
+    /**
+     * Gets the `index`th generic argument of this parametrized canonical path (0-based).
+     */
+    TypeGenericArg getGenericArg(int index) {
+      result =
+        Synth::convertTypeGenericArgFromRaw(Synth::convertParametrizedCanonicalPathToRaw(this)
+              .(Raw::ParametrizedCanonicalPath)
+              .getGenericArg(index))
+    }
+
+    /**
+     * Gets any of the generic arguments of this parametrized canonical path.
+     */
+    final TypeGenericArg getAGenericArg() { result = this.getGenericArg(_) }
+
+    /**
+     * Gets the number of generic arguments of this parametrized canonical path.
+     */
+    final int getNumberOfGenericArgs() { result = count(int i | exists(this.getGenericArg(i))) }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/PlaceholderTypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/PlaceholderTypeCanonicalPath.qll
new file mode 100644
index 000000000000..f3e91fb8031b
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/PlaceholderTypeCanonicalPath.qll
@@ -0,0 +1,26 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `PlaceholderTypeCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.TypeCanonicalPathImpl::Impl as TypeCanonicalPathImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `PlaceholderTypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A placeholder for a type parameter bound in an impl.
+   * INTERNAL: Do not reference the `Generated::PlaceholderTypeCanonicalPath` class directly.
+   * Use the subclass `PlaceholderTypeCanonicalPath`, where the following predicates are available.
+   */
+  class PlaceholderTypeCanonicalPath extends Synth::TPlaceholderTypeCanonicalPath,
+    TypeCanonicalPathImpl::TypeCanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "PlaceholderTypeCanonicalPath" }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TraitImplItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TraitImplItemCanonicalPath.qll
new file mode 100644
index 000000000000..d0906391c87e
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TraitImplItemCanonicalPath.qll
@@ -0,0 +1,58 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TraitImplItemCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.ParametrizedCanonicalPath
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TraitImplItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for an item defined in a trait impl.
+   * INTERNAL: Do not reference the `Generated::TraitImplItemCanonicalPath` class directly.
+   * Use the subclass `TraitImplItemCanonicalPath`, where the following predicates are available.
+   */
+  class TraitImplItemCanonicalPath extends Synth::TTraitImplItemCanonicalPath,
+    CanonicalPathImpl::CanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "TraitImplItemCanonicalPath" }
+
+    /**
+     * Gets the type path of this trait impl item canonical path.
+     */
+    TypeCanonicalPath getTypePath() {
+      result =
+        Synth::convertTypeCanonicalPathFromRaw(Synth::convertTraitImplItemCanonicalPathToRaw(this)
+              .(Raw::TraitImplItemCanonicalPath)
+              .getTypePath())
+    }
+
+    /**
+     * Gets the trait path of this trait impl item canonical path.
+     */
+    ParametrizedCanonicalPath getTraitPath() {
+      result =
+        Synth::convertParametrizedCanonicalPathFromRaw(Synth::convertTraitImplItemCanonicalPathToRaw(this)
+              .(Raw::TraitImplItemCanonicalPath)
+              .getTraitPath())
+    }
+
+    /**
+     * Gets the name of this trait impl item canonical path.
+     */
+    string getName() {
+      result =
+        Synth::convertTraitImplItemCanonicalPathToRaw(this)
+            .(Raw::TraitImplItemCanonicalPath)
+            .getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeCanonicalPath.qll
new file mode 100644
index 000000000000..27c45a94fb0d
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeCanonicalPath.qll
@@ -0,0 +1,22 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TypeCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TypeCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * The base for canonical paths for types.
+   * INTERNAL: Do not reference the `Generated::TypeCanonicalPath` class directly.
+   * Use the subclass `TypeCanonicalPath`, where the following predicates are available.
+   */
+  class TypeCanonicalPath extends Synth::TTypeCanonicalPath, CanonicalPathImpl::CanonicalPath { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericArg.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericArg.qll
new file mode 100644
index 000000000000..9b0550919bac
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericArg.qll
@@ -0,0 +1,24 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TypeGenericArg`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathElementImpl::Impl as CanonicalPathElementImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TypeGenericArg` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A generic argument for a type.
+   * INTERNAL: Do not reference the `Generated::TypeGenericArg` class directly.
+   * Use the subclass `TypeGenericArg`, where the following predicates are available.
+   */
+  class TypeGenericArg extends Synth::TTypeGenericArg,
+    CanonicalPathElementImpl::CanonicalPathElement
+  { }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericTypeArg.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericTypeArg.qll
new file mode 100644
index 000000000000..972a7e7216dd
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeGenericTypeArg.qll
@@ -0,0 +1,35 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TypeGenericTypeArg`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.TypeCanonicalPath
+import codeql.rust.elements.canonical_paths.internal.TypeGenericArgImpl::Impl as TypeGenericArgImpl
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TypeGenericTypeArg` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A generic argument for a type that is a type.
+   * INTERNAL: Do not reference the `Generated::TypeGenericTypeArg` class directly.
+   * Use the subclass `TypeGenericTypeArg`, where the following predicates are available.
+   */
+  class TypeGenericTypeArg extends Synth::TTypeGenericTypeArg, TypeGenericArgImpl::TypeGenericArg {
+    override string getAPrimaryQlClass() { result = "TypeGenericTypeArg" }
+
+    /**
+     * Gets the path of this type generic type argument.
+     */
+    TypeCanonicalPath getPath() {
+      result =
+        Synth::convertTypeCanonicalPathFromRaw(Synth::convertTypeGenericTypeArgToRaw(this)
+              .(Raw::TypeGenericTypeArg)
+              .getPath())
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeImplItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeImplItemCanonicalPath.qll
new file mode 100644
index 000000000000..baf76a691d82
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeImplItemCanonicalPath.qll
@@ -0,0 +1,47 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TypeImplItemCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TypeImplItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for an item defined in a type impl.
+   * INTERNAL: Do not reference the `Generated::TypeImplItemCanonicalPath` class directly.
+   * Use the subclass `TypeImplItemCanonicalPath`, where the following predicates are available.
+   */
+  class TypeImplItemCanonicalPath extends Synth::TTypeImplItemCanonicalPath,
+    CanonicalPathImpl::CanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "TypeImplItemCanonicalPath" }
+
+    /**
+     * Gets the parent of this type impl item canonical path.
+     */
+    ModuleItemCanonicalPath getParent() {
+      result =
+        Synth::convertModuleItemCanonicalPathFromRaw(Synth::convertTypeImplItemCanonicalPathToRaw(this)
+              .(Raw::TypeImplItemCanonicalPath)
+              .getParent())
+    }
+
+    /**
+     * Gets the name of this type impl item canonical path.
+     */
+    string getName() {
+      result =
+        Synth::convertTypeImplItemCanonicalPathToRaw(this)
+            .(Raw::TypeImplItemCanonicalPath)
+            .getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeItemCanonicalPath.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeItemCanonicalPath.qll
new file mode 100644
index 000000000000..33caa222a2bb
--- /dev/null
+++ b/rust/ql/lib/codeql/rust/elements/internal/generated/canonical_paths/TypeItemCanonicalPath.qll
@@ -0,0 +1,44 @@
+// generated by codegen, do not edit
+/**
+ * This module provides the generated definition of `TypeItemCanonicalPath`.
+ * INTERNAL: Do not import directly.
+ */
+
+private import codeql.rust.elements.internal.generated.Synth
+private import codeql.rust.elements.internal.generated.Raw
+import codeql.rust.elements.canonical_paths.internal.CanonicalPathImpl::Impl as CanonicalPathImpl
+import codeql.rust.elements.canonical_paths.ModuleItemCanonicalPath
+
+/**
+ * INTERNAL: This module contains the fully generated definition of `TypeItemCanonicalPath` and should not
+ * be referenced directly.
+ */
+module Generated {
+  /**
+   * A canonical path for an item defined in a type or trait.
+   * INTERNAL: Do not reference the `Generated::TypeItemCanonicalPath` class directly.
+   * Use the subclass `TypeItemCanonicalPath`, where the following predicates are available.
+   */
+  class TypeItemCanonicalPath extends Synth::TTypeItemCanonicalPath,
+    CanonicalPathImpl::CanonicalPath
+  {
+    override string getAPrimaryQlClass() { result = "TypeItemCanonicalPath" }
+
+    /**
+     * Gets the parent of this type item canonical path.
+     */
+    ModuleItemCanonicalPath getParent() {
+      result =
+        Synth::convertModuleItemCanonicalPathFromRaw(Synth::convertTypeItemCanonicalPathToRaw(this)
+              .(Raw::TypeItemCanonicalPath)
+              .getParent())
+    }
+
+    /**
+     * Gets the name of this type item canonical path.
+     */
+    string getName() {
+      result = Synth::convertTypeItemCanonicalPathToRaw(this).(Raw::TypeItemCanonicalPath).getName()
+    }
+  }
+}
diff --git a/rust/ql/lib/codeql/rust/frameworks/Reqwest.qll b/rust/ql/lib/codeql/rust/frameworks/Reqwest.qll
index 2d3e04f94b3b..b62498702f8b 100644
--- a/rust/ql/lib/codeql/rust/frameworks/Reqwest.qll
+++ b/rust/ql/lib/codeql/rust/frameworks/Reqwest.qll
@@ -12,8 +12,7 @@ private class ReqwestGet extends RemoteSource::Range {
   ReqwestGet() {
     exists(CallExpr ce |
       this.asExpr().getExpr() = ce and
-      ce.getFunction().(PathExpr).getResolvedCrateOrigin().matches("%reqwest") and
-      ce.getFunction().(PathExpr).getResolvedPath() = ["crate::get", "crate::blocking::get"]
+      ce.getFunction().(PathExpr).resolvesToStandardPath(["reqwest", "reqwest::blocking"], "get")
     )
   }
 }
diff --git a/rust/ql/lib/codeql/rust/frameworks/RustCrypto.qll b/rust/ql/lib/codeql/rust/frameworks/RustCrypto.qll
index 9dd40004766a..0428491bda18 100644
--- a/rust/ql/lib/codeql/rust/frameworks/RustCrypto.qll
+++ b/rust/ql/lib/codeql/rust/frameworks/RustCrypto.qll
@@ -22,28 +22,22 @@ class StreamCipherInit extends Cryptography::CryptographicOperation::Range {
   StreamCipherInit() {
     // a call to `cipher::KeyInit::new`, `cipher::KeyInit::new_from_slice`,
     // `cipher::KeyIvInit::new`, `cipher::KeyIvInit::new_from_slices` or `rc2::Rc2::new_with_eff_key_len`.
-    exists(PathExpr p, string rawAlgorithmName |
-      this.asExpr().getExpr().(CallExpr).getFunction() = p and
-      p.getResolvedCrateOrigin().matches("%/RustCrypto%") and
-      p.getPath().getPart().getNameRef().getText() =
-        ["new", "new_from_slice", "new_from_slices", "new_with_eff_key_len"] and
-      (
-        rawAlgorithmName = p.getPath().getQualifier().getPart().getNameRef().getText() or
-        rawAlgorithmName =
-          p.getPath()
-              .getQualifier()
-              .getPart()
-              .getGenericArgList()
-              .getGenericArg(0)
-              .(TypeArg)
-              .getTypeRepr()
-              .(PathTypeRepr)
-              .getPath()
-              .getPart()
-              .getNameRef()
-              .getText()
-      ) and
-      algorithmName = simplifyAlgorithmName(rawAlgorithmName)
+    exists(PathExpr e |
+      e = this.asExpr().getExpr().(CallExpr).getFunction() and
+      exists(TraitImplItemCanonicalPath path, string rawAlgorithmName |
+        path = e.getResolvedCanonicalPath() and
+        path.getTraitPath().getBase().hasStandardPath("crypto-common", ["KeyInit", "KeyIvInit"]) and
+        path.getName() = ["new", "new_from_slice", "new_from_slices"] and
+        path.getTypePath()
+            .(ConcreteTypeCanonicalPath)
+            .getPath()
+            .getBase()
+            .hasStandardPath(_, rawAlgorithmName) and
+        algorithmName = simplifyAlgorithmName(rawAlgorithmName)
+      )
+      or
+      e.resolvesToStandardPath("rc2::Rc2", "new_with_eff_key_len") and
+      algorithmName = "Rc2"
     )
   }
 
diff --git a/rust/ql/lib/codeql/rust/frameworks/Sqlx.qll b/rust/ql/lib/codeql/rust/frameworks/Sqlx.qll
index 5504993ab744..b297e620c32c 100644
--- a/rust/ql/lib/codeql/rust/frameworks/Sqlx.qll
+++ b/rust/ql/lib/codeql/rust/frameworks/Sqlx.qll
@@ -14,12 +14,15 @@ private class SqlxQuery extends SqlConstruction::Range {
 
   SqlxQuery() {
     this.asExpr().getExpr() = call and
-    call.getFunction().(PathExpr).getResolvedPath() =
-      [
-        "crate::query::query", "crate::query_as::query_as", "crate::query_with::query_with",
-        "crate::query_as_with::query_as_with", "crate::query_scalar::query_scalar",
-        "crate::query_scalar_with::query_scalar_with", "crate::raw_sql::raw_sql"
-      ]
+    exists(PathExpr path, string name |
+      call.getFunction() = path and
+      name =
+        [
+          "query", "query_as", "query_with", "query_as_with", "query_scalar", "query_scalar_with",
+          "raw_sql"
+        ] and
+      path.resolvesToStandardPath("sqlx::" + name, name)
+    )
   }
 
   override DataFlow::Node getSql() { result.asExpr().getExpr() = call.getArgList().getArg(0) }
@@ -33,7 +36,7 @@ private class SqlxExecute extends SqlExecution::Range {
 
   SqlxExecute() {
     this.asExpr().getExpr() = call and
-    call.(Resolvable).getResolvedPath() = "crate::executor::Executor::execute"
+    call.(Resolvable).resolvesToStandardPath("sqlx::executor", "Executor", "execute")
   }
 
   override DataFlow::Node getSql() { result.asExpr().getExpr() = call.getArgList().getArg(0) }
diff --git a/rust/ql/lib/codeql/rust/frameworks/stdlib/Env.qll b/rust/ql/lib/codeql/rust/frameworks/stdlib/Env.qll
index 8410da77a069..547b4b08f51d 100644
--- a/rust/ql/lib/codeql/rust/frameworks/stdlib/Env.qll
+++ b/rust/ql/lib/codeql/rust/frameworks/stdlib/Env.qll
@@ -10,8 +10,12 @@ private import codeql.rust.Concepts
  */
 private class StdEnvArgs extends CommandLineArgsSource::Range {
   StdEnvArgs() {
-    this.asExpr().getExpr().(CallExpr).getFunction().(PathExpr).getResolvedPath() =
-      ["crate::env::args", "crate::env::args_os"]
+    this.asExpr()
+        .getExpr()
+        .(CallExpr)
+        .getFunction()
+        .(PathExpr)
+        .resolvesToStandardPath("std::env", ["args", "args_os"])
   }
 }
 
@@ -20,8 +24,12 @@ private class StdEnvArgs extends CommandLineArgsSource::Range {
  */
 private class StdEnvDir extends CommandLineArgsSource::Range {
   StdEnvDir() {
-    this.asExpr().getExpr().(CallExpr).getFunction().(PathExpr).getResolvedPath() =
-      ["crate::env::current_dir", "crate::env::current_exe", "crate::env::home_dir"]
+    this.asExpr()
+        .getExpr()
+        .(CallExpr)
+        .getFunction()
+        .(PathExpr)
+        .resolvesToStandardPath("std::env", ["current_dir", "current_exe", "home_dir"])
   }
 }
 
@@ -30,7 +38,11 @@ private class StdEnvDir extends CommandLineArgsSource::Range {
  */
 private class StdEnvVar extends EnvironmentSource::Range {
   StdEnvVar() {
-    this.asExpr().getExpr().(CallExpr).getFunction().(PathExpr).getResolvedPath() =
-      ["crate::env::var", "crate::env::var_os", "crate::env::vars", "crate::env::vars_os"]
+    this.asExpr()
+        .getExpr()
+        .(CallExpr)
+        .getFunction()
+        .(PathExpr)
+        .resolvesToStandardPath("std::env", ["var", "var_os", "vars", "vars_os"])
   }
 }
diff --git a/rust/ql/lib/rust.dbscheme b/rust/ql/lib/rust.dbscheme
index d706df19af4a..904b4212d991 100644
--- a/rust/ql/lib/rust.dbscheme
+++ b/rust/ql/lib/rust.dbscheme
@@ -120,7 +120,8 @@ locatable_locations(
 // from schema
 
 @element =
-  @extractor_step
+  @canonical_path_element
+| @extractor_step
 | @locatable
 | @unextracted
 ;
@@ -226,15 +227,9 @@ abi_abi_strings(
 ;
 
 #keyset[id]
-addressable_extended_canonical_paths(
+addressable_canonical_paths(
   int id: @addressable ref,
-  string extended_canonical_path: string ref
-);
-
-#keyset[id]
-addressable_crate_origins(
-  int id: @addressable ref,
-  string crate_origin: string ref
+  int canonical_path: @canonical_path ref
 );
 
 arg_lists(
@@ -855,15 +850,9 @@ rename_names(
 ;
 
 #keyset[id]
-resolvable_resolved_paths(
-  int id: @resolvable ref,
-  string resolved_path: string ref
-);
-
-#keyset[id]
-resolvable_resolved_crate_origins(
+resolvable_resolved_canonical_paths(
   int id: @resolvable ref,
-  string resolved_crate_origin: string ref
+  int resolved_canonical_path: @canonical_path ref
 );
 
 ret_type_reprs(
@@ -3340,3 +3329,149 @@ while_expr_conditions(
   int id: @while_expr ref,
   int condition: @expr ref
 );
+
+@canonical_path_element =
+  @canonical_path
+| @crate_ref
+| @type_generic_arg
+;
+
+@canonical_path =
+  @module_item_canonical_path
+| @namespace
+| @parametrized_canonical_path
+| @trait_impl_item_canonical_path
+| @type_canonical_path
+| @type_impl_item_canonical_path
+| @type_item_canonical_path
+;
+
+@crate_ref =
+  @lang_crate_ref
+| @repo_crate_ref
+| @rustc_crate_ref
+;
+
+@type_generic_arg =
+  @const_generic_type_arg
+| @type_generic_type_arg
+;
+
+const_generic_type_args(  //dir=canonical_paths
+  unique int id: @const_generic_type_arg,
+  string value: string ref
+);
+
+lang_crate_refs(  //dir=canonical_paths
+  unique int id: @lang_crate_ref,
+  string name: string ref
+);
+
+module_item_canonical_paths(  //dir=canonical_paths
+  unique int id: @module_item_canonical_path,
+  int namespace: @namespace ref,
+  string name: string ref
+);
+
+namespaces(  //dir=canonical_paths
+  unique int id: @namespace,
+  int root: @crate_ref ref,
+  string path: string ref
+);
+
+parametrized_canonical_paths(  //dir=canonical_paths
+  unique int id: @parametrized_canonical_path,
+  int base: @module_item_canonical_path ref
+);
+
+#keyset[id, index]
+parametrized_canonical_path_generic_args(  //dir=canonical_paths
+  int id: @parametrized_canonical_path ref,
+  int index: int ref,
+  int generic_arg: @type_generic_arg ref
+);
+
+repo_crate_refs(  //dir=canonical_paths
+  unique int id: @repo_crate_ref,
+  int source: @file ref
+);
+
+#keyset[id]
+repo_crate_ref_names(  //dir=canonical_paths
+  int id: @repo_crate_ref ref,
+  string name: string ref
+);
+
+#keyset[id]
+repo_crate_ref_repos(  //dir=canonical_paths
+  int id: @repo_crate_ref ref,
+  string repo: string ref
+);
+
+rustc_crate_refs(  //dir=canonical_paths
+  unique int id: @rustc_crate_ref,
+  string name: string ref
+);
+
+trait_impl_item_canonical_paths(  //dir=canonical_paths
+  unique int id: @trait_impl_item_canonical_path,
+  int type_path: @type_canonical_path ref,
+  int trait_path: @parametrized_canonical_path ref,
+  string name: string ref
+);
+
+@type_canonical_path =
+  @builtin_type_canonical_path
+| @concrete_type_canonical_path
+| @derived_type_canonical_path
+| @placeholder_type_canonical_path
+;
+
+type_generic_type_args(  //dir=canonical_paths
+  unique int id: @type_generic_type_arg,
+  int path: @type_canonical_path ref
+);
+
+type_impl_item_canonical_paths(  //dir=canonical_paths
+  unique int id: @type_impl_item_canonical_path,
+  int parent: @module_item_canonical_path ref,
+  string name: string ref
+);
+
+type_item_canonical_paths(  //dir=canonical_paths
+  unique int id: @type_item_canonical_path,
+  int parent: @module_item_canonical_path ref,
+  string name: string ref
+);
+
+builtin_type_canonical_paths(  //dir=canonical_paths
+  unique int id: @builtin_type_canonical_path,
+  string name: string ref
+);
+
+concrete_type_canonical_paths(  //dir=canonical_paths
+  unique int id: @concrete_type_canonical_path,
+  int path: @parametrized_canonical_path ref
+);
+
+derived_type_canonical_paths(  //dir=canonical_paths
+  unique int id: @derived_type_canonical_path
+);
+
+#keyset[id, index]
+derived_type_canonical_path_modifiers(  //dir=canonical_paths
+  int id: @derived_type_canonical_path ref,
+  int index: int ref,
+  string modifier: string ref
+);
+
+#keyset[id, index]
+derived_type_canonical_path_bases(  //dir=canonical_paths
+  int id: @derived_type_canonical_path ref,
+  int index: int ref,
+  int base: @type_canonical_path ref
+);
+
+placeholder_type_canonical_paths(  //dir=canonical_paths
+  unique int id: @placeholder_type_canonical_path
+);
diff --git a/rust/ql/src/queries/security/CWE-696/BadCtorInitialization.ql b/rust/ql/src/queries/security/CWE-696/BadCtorInitialization.ql
index 221b8e4eb090..a50027dfe813 100644
--- a/rust/ql/src/queries/security/CWE-696/BadCtorInitialization.ql
+++ b/rust/ql/src/queries/security/CWE-696/BadCtorInitialization.ql
@@ -32,8 +32,12 @@ class CtorAttr extends Attr {
  */
 class StdCall extends Expr {
   StdCall() {
-    this.(CallExpr).getFunction().(PathExpr).getResolvedCrateOrigin() = "lang:std" or
-    this.(MethodCallExpr).getResolvedCrateOrigin() = "lang:std"
+    exists(string namespace |
+      this.(CallExpr).getFunction().(PathExpr).resolvesToStandardPath(namespace, _)
+      or
+      this.(MethodCallExpr).resolvesToStandardPath(namespace, _, _) and
+      namespace.matches("std::%")
+    )
   }
 }
 
diff --git a/rust/ql/test/extractor-tests/canonical_path/canonical_paths.expected b/rust/ql/test/extractor-tests/canonical_path/canonical_paths.expected
index 4f0f2ec96fb6..3bb1bc9744eb 100644
--- a/rust/ql/test/extractor-tests/canonical_path/canonical_paths.expected
+++ b/rust/ql/test/extractor-tests/canonical_path/canonical_paths.expected
@@ -1,66 +1,204 @@
 canonicalPaths
-| anonymous.rs:1:1:1:26 | Use | None | None |
-| anonymous.rs:3:1:32:1 | fn canonicals | repo::test | crate::anonymous::canonicals |
-| anonymous.rs:4:5:4:23 | struct OtherStruct | repo::test | {0}::OtherStruct |
-| anonymous.rs:6:5:8:5 | trait OtherTrait | repo::test | {0}::OtherTrait |
-| anonymous.rs:7:9:7:20 | fn g | repo::test | {0}::OtherTrait::g |
-| anonymous.rs:10:5:12:5 | impl OtherTrait for OtherStruct { ... } | None | None |
-| anonymous.rs:11:9:11:22 | fn g | repo::test | <{0}::OtherStruct as {0}::OtherTrait>::g |
-| anonymous.rs:14:5:16:5 | impl OtherTrait for ...::Struct { ... } | None | None |
-| anonymous.rs:15:9:15:22 | fn g | repo::test | <crate::regular::Struct as {0}::OtherTrait>::g |
-| anonymous.rs:18:5:20:5 | impl ...::Trait for OtherStruct { ... } | None | None |
-| anonymous.rs:19:9:19:22 | fn f | repo::test | <{0}::OtherStruct as crate::regular::Trait>::f |
-| anonymous.rs:22:5:24:5 | fn nested | repo::test | {0}::nested |
-| anonymous.rs:23:9:23:27 | struct OtherStruct | repo::test | {1}::OtherStruct |
-| anonymous.rs:26:5:31:5 | fn usage | repo::test | {0}::usage |
-| anonymous.rs:34:1:36:1 | fn other | repo::test | crate::anonymous::other |
-| anonymous.rs:35:5:35:23 | struct OtherStruct | repo::test | {36}::OtherStruct |
-| lib.rs:1:1:1:14 | mod anonymous | repo::test | crate::anonymous |
-| lib.rs:2:1:2:12 | mod regular | repo::test | crate::regular |
-| regular.rs:1:1:2:18 | struct Struct | repo::test | crate::regular::Struct |
-| regular.rs:4:1:6:1 | trait Trait | repo::test | crate::regular::Trait |
-| regular.rs:5:5:5:16 | fn f | repo::test | crate::regular::Trait::f |
-| regular.rs:8:1:10:1 | impl Trait for Struct { ... } | None | None |
-| regular.rs:9:5:9:18 | fn f | repo::test | <crate::regular::Struct as crate::regular::Trait>::f |
-| regular.rs:12:1:14:1 | impl Struct { ... } | None | None |
-| regular.rs:13:5:13:18 | fn g | repo::test | <crate::regular::Struct>::g |
-| regular.rs:16:1:18:1 | trait TraitWithBlanketImpl | repo::test | crate::regular::TraitWithBlanketImpl |
-| regular.rs:17:5:17:16 | fn h | repo::test | crate::regular::TraitWithBlanketImpl::h |
-| regular.rs:20:1:22:1 | impl TraitWithBlanketImpl for T { ... } | None | None |
-| regular.rs:21:5:21:18 | fn h | repo::test | <_ as crate::regular::TraitWithBlanketImpl>::h |
-| regular.rs:24:1:24:12 | fn free | repo::test | crate::regular::free |
-| regular.rs:26:1:32:1 | fn usage | repo::test | crate::regular::usage |
-| regular.rs:34:1:38:1 | enum MyEnum | repo::test | crate::regular::MyEnum |
-| regular.rs:40:1:46:1 | fn enum_qualified_usage | repo::test | crate::regular::enum_qualified_usage |
-| regular.rs:48:1:55:1 | fn enum_unqualified_usage | repo::test | crate::regular::enum_unqualified_usage |
-| regular.rs:51:5:51:18 | Use | None | None |
-| regular.rs:57:1:63:1 | fn enum_match | repo::test | crate::regular::enum_match |
+| anonymous.rs:1:1:1:26 | Use | None |  |
+| anonymous.rs:3:1:32:1 | fn canonicals | ...::canonicals | ModuleItemCanonicalPath |
+| anonymous.rs:4:5:4:23 | struct OtherStruct | None |  |
+| anonymous.rs:6:5:8:5 | trait OtherTrait | None |  |
+| anonymous.rs:7:9:7:20 | fn g | None |  |
+| anonymous.rs:10:5:12:5 | impl OtherTrait for OtherStruct { ... } | None |  |
+| anonymous.rs:11:9:11:22 | fn g | None |  |
+| anonymous.rs:14:5:16:5 | impl OtherTrait for ...::Struct { ... } | None |  |
+| anonymous.rs:15:9:15:22 | fn g | <...>::g | TypeImplItemCanonicalPath |
+| anonymous.rs:18:5:20:5 | impl ...::Trait for OtherStruct { ... } | None |  |
+| anonymous.rs:19:9:19:22 | fn f | None |  |
+| anonymous.rs:22:5:24:5 | fn nested | None |  |
+| anonymous.rs:23:9:23:27 | struct OtherStruct | None |  |
+| anonymous.rs:26:5:31:5 | fn usage | None |  |
+| anonymous.rs:34:1:36:1 | fn other | ...::other | ModuleItemCanonicalPath |
+| anonymous.rs:35:5:35:23 | struct OtherStruct | None |  |
+| lib.rs:1:1:1:14 | mod anonymous | test::anonymous | Namespace |
+| lib.rs:2:1:2:12 | mod regular | test::regular | Namespace |
+| lib.rs:3:1:3:10 | mod usage | test::usage | Namespace |
+| regular.rs:1:1:2:18 | struct Struct | ...::Struct | ModuleItemCanonicalPath |
+| regular.rs:4:1:6:1 | trait Trait | ...::Trait | ModuleItemCanonicalPath |
+| regular.rs:5:5:5:16 | fn f | ...::f | TypeItemCanonicalPath |
+| regular.rs:8:1:10:1 | impl Trait for Struct { ... } | None |  |
+| regular.rs:9:5:9:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:12:1:14:1 | impl Struct { ... } | None |  |
+| regular.rs:13:5:13:22 | fn g | <...>::g | TypeImplItemCanonicalPath |
+| regular.rs:16:1:18:1 | trait TraitWithBlanketImpl | ...::TraitWithBlanketImpl | ModuleItemCanonicalPath |
+| regular.rs:17:5:17:16 | fn h | ...::h | TypeItemCanonicalPath |
+| regular.rs:20:1:22:1 | impl TraitWithBlanketImpl for T { ... } | None |  |
+| regular.rs:21:5:21:18 | fn h | <_ as ...>::h | TraitImplItemCanonicalPath |
+| regular.rs:24:1:24:16 | fn free | ...::free | ModuleItemCanonicalPath |
+| regular.rs:26:1:30:1 | enum MyEnum | ...::MyEnum | ModuleItemCanonicalPath |
+| regular.rs:27:5:27:12 | Variant1 | ...::Variant1 | TypeItemCanonicalPath |
+| regular.rs:28:5:28:19 | Variant2 | ...::Variant2 | TypeItemCanonicalPath |
+| regular.rs:29:5:29:25 | Variant3 | ...::Variant3 | TypeItemCanonicalPath |
+| regular.rs:32:1:34:1 | trait GenericTrait | ...::GenericTrait | ModuleItemCanonicalPath |
+| regular.rs:33:5:33:35 | fn generic_method | ...::generic_method | TypeItemCanonicalPath |
+| regular.rs:36:1:39:1 | struct GenericStruct | ...::GenericStruct | ModuleItemCanonicalPath |
+| regular.rs:41:1:41:50 | struct GenericTupleStruct | ...::GenericTupleStruct | ModuleItemCanonicalPath |
+| regular.rs:44:1:47:1 | enum GenericEnum | ...::GenericEnum | ModuleItemCanonicalPath |
+| regular.rs:45:5:45:8 | T | ...::T | TypeItemCanonicalPath |
+| regular.rs:46:5:46:8 | U | ...::U | TypeItemCanonicalPath |
+| regular.rs:49:1:51:1 | impl GenericTrait::<...> for GenericStruct::<...> { ... } | None |  |
+| regular.rs:50:5:50:37 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:53:1:55:1 | impl GenericTrait::<...> for GenericStruct::<...> { ... } | None |  |
+| regular.rs:54:5:54:39 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:57:1:59:1 | impl GenericTrait::<...> for GenericTupleStruct::<...> { ... } | None |  |
+| regular.rs:58:5:58:37 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:61:1:63:1 | impl GenericTrait::<...> for GenericTupleStruct::<...> { ... } | None |  |
+| regular.rs:62:5:62:39 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:65:1:67:1 | impl GenericTrait::<...> for GenericEnum::<...> { ... } | None |  |
+| regular.rs:66:5:66:37 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:69:1:71:1 | impl GenericTrait::<...> for GenericEnum::<...> { ... } | None |  |
+| regular.rs:70:5:70:39 | fn generic_method | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| regular.rs:73:1:75:1 | impl Trait for ... { ... } | None |  |
+| regular.rs:74:5:74:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:77:1:79:1 | impl Trait for ... { ... } | None |  |
+| regular.rs:78:5:78:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:81:1:83:1 | impl Trait for ... { ... } | None |  |
+| regular.rs:82:5:82:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:85:1:87:1 | impl Trait for ... { ... } | None |  |
+| regular.rs:86:5:86:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:89:1:91:1 | impl Trait for ... { ... } | None |  |
+| regular.rs:90:5:90:18 | fn f | <... as ...>::f | TraitImplItemCanonicalPath |
+| regular.rs:93:1:95:1 | trait TraitWithNew | ...::TraitWithNew | ModuleItemCanonicalPath |
+| regular.rs:94:5:94:21 | fn new | ...::new | TypeItemCanonicalPath |
+| regular.rs:97:1:101:1 | impl TraitWithNew for GenericStruct::<...> { ... } | None |  |
+| regular.rs:98:5:100:5 | fn new | <... as ...>::new | TraitImplItemCanonicalPath |
+| usage.rs:1:1:1:22 | Use | None |  |
+| usage.rs:3:1:9:1 | fn usage | ...::usage | ModuleItemCanonicalPath |
+| usage.rs:11:1:17:1 | fn enum_qualified_usage | ...::enum_qualified_usage | ModuleItemCanonicalPath |
+| usage.rs:19:1:26:1 | fn enum_unqualified_usage | ...::enum_unqualified_usage | ModuleItemCanonicalPath |
+| usage.rs:22:5:22:18 | Use | None |  |
+| usage.rs:28:1:34:1 | fn enum_match | ...::enum_match | ModuleItemCanonicalPath |
+| usage.rs:36:1:49:1 | fn generic_usage | ...::generic_usage | ModuleItemCanonicalPath |
+| usage.rs:51:1:57:1 | fn use_trait | ...::use_trait | ModuleItemCanonicalPath |
+| usage.rs:54:5:54:17 | vec!... | None |  |
+| usage.rs:59:1:61:1 | fn use_trait_with_new | ...::use_trait_with_new | ModuleItemCanonicalPath |
 resolvedPaths
-| anonymous.rs:27:17:27:30 | OtherStruct {...} | repo::test | {0}::OtherStruct |
-| anonymous.rs:28:9:28:9 | s | None | None |
-| anonymous.rs:28:9:28:13 | s.f(...) | repo::test | <{0}::OtherStruct as crate::regular::Trait>::f |
-| anonymous.rs:29:9:29:9 | s | None | None |
-| anonymous.rs:29:9:29:13 | s.g(...) | repo::test | <{0}::OtherStruct as {0}::OtherTrait>::g |
-| anonymous.rs:30:9:30:14 | nested | repo::test | {0}::nested |
-| regular.rs:27:13:27:21 | Struct {...} | repo::test | crate::regular::Struct |
-| regular.rs:28:5:28:5 | s | None | None |
-| regular.rs:28:5:28:9 | s.f(...) | repo::test | <crate::regular::Struct as crate::regular::Trait>::f |
-| regular.rs:29:5:29:5 | s | None | None |
-| regular.rs:29:5:29:9 | s.g(...) | repo::test | <crate::regular::Struct>::g |
-| regular.rs:30:5:30:5 | s | None | None |
-| regular.rs:30:5:30:9 | s.h(...) | repo::test | <_ as crate::regular::TraitWithBlanketImpl>::h |
-| regular.rs:31:5:31:8 | free | repo::test | crate::regular::free |
-| regular.rs:41:9:41:26 | ...::None::<...> | lang:core | crate::option::Option::None |
-| regular.rs:42:9:42:20 | ...::Some | lang:core | crate::option::Option::Some |
-| regular.rs:43:9:43:24 | ...::Variant1 | repo::test | crate::regular::MyEnum::Variant1 |
-| regular.rs:44:9:44:24 | ...::Variant2 | repo::test | crate::regular::MyEnum::Variant2 |
-| regular.rs:45:9:45:33 | ...::Variant3 {...} | repo::test | crate::regular::MyEnum::Variant3 |
-| regular.rs:49:9:49:18 | None::<...> | lang:core | crate::option::Option::None |
-| regular.rs:50:9:50:12 | Some | lang:core | crate::option::Option::Some |
-| regular.rs:52:9:52:16 | Variant1 | repo::test | crate::regular::MyEnum::Variant1 |
-| regular.rs:53:9:53:16 | Variant2 | repo::test | crate::regular::MyEnum::Variant2 |
-| regular.rs:54:9:54:25 | Variant3 {...} | repo::test | crate::regular::MyEnum::Variant3 |
-| regular.rs:58:11:58:11 | e | None | None |
-| regular.rs:59:9:59:24 | ...::Variant1 | repo::test | crate::regular::MyEnum::Variant1 |
-| regular.rs:60:9:60:27 | ...::Variant2(...) | repo::test | crate::regular::MyEnum::Variant2 |
-| regular.rs:61:9:61:31 | ...::Variant3 {...} | repo::test | crate::regular::MyEnum::Variant3 |
+| anonymous.rs:27:17:27:30 | OtherStruct {...} | None |  |
+| anonymous.rs:28:9:28:9 | s | None |  |
+| anonymous.rs:28:9:28:13 | s.f(...) | None |  |
+| anonymous.rs:29:9:29:9 | s | None |  |
+| anonymous.rs:29:9:29:13 | s.g(...) | None |  |
+| anonymous.rs:30:9:30:14 | nested | None |  |
+| regular.rs:99:9:99:67 | GenericStruct {...} | ...::GenericStruct | ModuleItemCanonicalPath |
+| regular.rs:99:26:99:41 | ...::default | ...::default | TypeItemCanonicalPath |
+| regular.rs:99:49:99:64 | ...::default | ...::default | TypeItemCanonicalPath |
+| usage.rs:4:13:4:21 | Struct {...} | ...::Struct | ModuleItemCanonicalPath |
+| usage.rs:5:5:5:5 | s | None |  |
+| usage.rs:5:5:5:9 | s.f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:6:5:6:5 | s | None |  |
+| usage.rs:6:5:6:9 | s.g(...) | <...>::g | TypeImplItemCanonicalPath |
+| usage.rs:7:5:7:5 | s | None |  |
+| usage.rs:7:5:7:9 | s.h(...) | <_ as ...>::h | TraitImplItemCanonicalPath |
+| usage.rs:8:5:8:8 | free | ...::free | ModuleItemCanonicalPath |
+| usage.rs:12:9:12:26 | ...::None::<...> | ...::None | TypeItemCanonicalPath |
+| usage.rs:13:9:13:20 | ...::Some | ...::Some | TypeItemCanonicalPath |
+| usage.rs:14:9:14:24 | ...::Variant1 | ...::Variant1 | TypeItemCanonicalPath |
+| usage.rs:15:9:15:24 | ...::Variant2 | ...::Variant2 | TypeItemCanonicalPath |
+| usage.rs:16:9:16:33 | ...::Variant3 {...} | ...::Variant3 | TypeItemCanonicalPath |
+| usage.rs:20:9:20:18 | None::<...> | ...::None | TypeItemCanonicalPath |
+| usage.rs:21:9:21:12 | Some | ...::Some | TypeItemCanonicalPath |
+| usage.rs:23:9:23:16 | Variant1 | ...::Variant1 | TypeItemCanonicalPath |
+| usage.rs:24:9:24:16 | Variant2 | ...::Variant2 | TypeItemCanonicalPath |
+| usage.rs:25:9:25:25 | Variant3 {...} | ...::Variant3 | TypeItemCanonicalPath |
+| usage.rs:29:11:29:11 | e | None |  |
+| usage.rs:30:9:30:24 | ...::Variant1 | ...::Variant1 | TypeItemCanonicalPath |
+| usage.rs:31:9:31:27 | ...::Variant2(...) | ...::Variant2 | TypeItemCanonicalPath |
+| usage.rs:32:9:32:31 | ...::Variant3 {...} | ...::Variant3 | TypeItemCanonicalPath |
+| usage.rs:37:13:37:41 | GenericStruct {...} | ...::GenericStruct | ModuleItemCanonicalPath |
+| usage.rs:38:5:38:5 | x | None |  |
+| usage.rs:38:5:38:26 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:39:13:39:47 | GenericStruct {...} | ...::GenericStruct | ModuleItemCanonicalPath |
+| usage.rs:40:5:40:5 | x | None |  |
+| usage.rs:40:5:40:23 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:41:13:41:30 | GenericTupleStruct | ...::GenericTupleStruct | ModuleItemCanonicalPath |
+| usage.rs:42:5:42:5 | x | None |  |
+| usage.rs:42:5:42:26 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:43:13:43:30 | GenericTupleStruct | ...::GenericTupleStruct | ModuleItemCanonicalPath |
+| usage.rs:44:5:44:5 | x | None |  |
+| usage.rs:44:5:44:23 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:45:13:45:37 | ...::T | ...::T | TypeItemCanonicalPath |
+| usage.rs:46:5:46:5 | x | None |  |
+| usage.rs:46:5:46:27 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:47:13:47:37 | ...::U | ...::U | TypeItemCanonicalPath |
+| usage.rs:48:5:48:5 | x | None |  |
+| usage.rs:48:5:48:23 | x.generic_method(...) | <... as ...>::generic_method | TraitImplItemCanonicalPath |
+| usage.rs:52:5:52:10 | ... .f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:53:5:53:15 | ... .f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:54:5:54:17 | ...::into_vec | None |  |
+| usage.rs:54:5:54:17 | ...::new | None |  |
+| usage.rs:54:5:54:28 | ... .as_slice(...) | <...>::as_slice | TypeImplItemCanonicalPath |
+| usage.rs:54:5:54:32 | ... .f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:55:5:55:16 | ... .f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:56:5:56:20 | ... .f(...) | <... as ...>::f | TraitImplItemCanonicalPath |
+| usage.rs:60:43:60:60 | ...::new | <... as ...>::new | TraitImplItemCanonicalPath |
+standardPaths
+| anonymous.rs:3:1:32:1 | fn canonicals | test::anonymous::canonicals |
+| anonymous.rs:15:9:15:22 | fn g | test::regular::Struct::g |
+| anonymous.rs:34:1:36:1 | fn other | test::anonymous::other |
+| regular.rs:1:1:2:18 | struct Struct | test::regular::Struct |
+| regular.rs:4:1:6:1 | trait Trait | test::regular::Trait |
+| regular.rs:5:5:5:16 | fn f | test::regular::Trait::f |
+| regular.rs:13:5:13:22 | fn g | test::regular::Struct::g |
+| regular.rs:16:1:18:1 | trait TraitWithBlanketImpl | test::regular::TraitWithBlanketImpl |
+| regular.rs:17:5:17:16 | fn h | test::regular::TraitWithBlanketImpl::h |
+| regular.rs:24:1:24:16 | fn free | test::regular::free |
+| regular.rs:26:1:30:1 | enum MyEnum | test::regular::MyEnum |
+| regular.rs:27:5:27:12 | Variant1 | test::regular::MyEnum::Variant1 |
+| regular.rs:28:5:28:19 | Variant2 | test::regular::MyEnum::Variant2 |
+| regular.rs:29:5:29:25 | Variant3 | test::regular::MyEnum::Variant3 |
+| regular.rs:32:1:34:1 | trait GenericTrait | test::regular::GenericTrait |
+| regular.rs:33:5:33:35 | fn generic_method | test::regular::GenericTrait::generic_method |
+| regular.rs:36:1:39:1 | struct GenericStruct | test::regular::GenericStruct |
+| regular.rs:41:1:41:50 | struct GenericTupleStruct | test::regular::GenericTupleStruct |
+| regular.rs:44:1:47:1 | enum GenericEnum | test::regular::GenericEnum |
+| regular.rs:45:5:45:8 | T | test::regular::GenericEnum::T |
+| regular.rs:46:5:46:8 | U | test::regular::GenericEnum::U |
+| regular.rs:93:1:95:1 | trait TraitWithNew | test::regular::TraitWithNew |
+| regular.rs:94:5:94:21 | fn new | test::regular::TraitWithNew::new |
+| usage.rs:3:1:9:1 | fn usage | test::usage::usage |
+| usage.rs:11:1:17:1 | fn enum_qualified_usage | test::usage::enum_qualified_usage |
+| usage.rs:19:1:26:1 | fn enum_unqualified_usage | test::usage::enum_unqualified_usage |
+| usage.rs:28:1:34:1 | fn enum_match | test::usage::enum_match |
+| usage.rs:36:1:49:1 | fn generic_usage | test::usage::generic_usage |
+| usage.rs:51:1:57:1 | fn use_trait | test::usage::use_trait |
+| usage.rs:59:1:61:1 | fn use_trait_with_new | test::usage::use_trait_with_new |
+resolve
+| regular.rs:99:9:99:67 | GenericStruct {...} | regular.rs:36:1:39:1 | struct GenericStruct |
+| usage.rs:4:13:4:21 | Struct {...} | regular.rs:1:1:2:18 | struct Struct |
+| usage.rs:5:5:5:9 | s.f(...) | regular.rs:9:5:9:18 | fn f |
+| usage.rs:6:5:6:9 | s.g(...) | anonymous.rs:15:9:15:22 | fn g |
+| usage.rs:6:5:6:9 | s.g(...) | regular.rs:13:5:13:22 | fn g |
+| usage.rs:7:5:7:9 | s.h(...) | regular.rs:21:5:21:18 | fn h |
+| usage.rs:8:5:8:8 | free | regular.rs:24:1:24:16 | fn free |
+| usage.rs:14:9:14:24 | ...::Variant1 | regular.rs:27:5:27:12 | Variant1 |
+| usage.rs:15:9:15:24 | ...::Variant2 | regular.rs:28:5:28:19 | Variant2 |
+| usage.rs:16:9:16:33 | ...::Variant3 {...} | regular.rs:29:5:29:25 | Variant3 |
+| usage.rs:23:9:23:16 | Variant1 | regular.rs:27:5:27:12 | Variant1 |
+| usage.rs:24:9:24:16 | Variant2 | regular.rs:28:5:28:19 | Variant2 |
+| usage.rs:25:9:25:25 | Variant3 {...} | regular.rs:29:5:29:25 | Variant3 |
+| usage.rs:30:9:30:24 | ...::Variant1 | regular.rs:27:5:27:12 | Variant1 |
+| usage.rs:31:9:31:27 | ...::Variant2(...) | regular.rs:28:5:28:19 | Variant2 |
+| usage.rs:32:9:32:31 | ...::Variant3 {...} | regular.rs:29:5:29:25 | Variant3 |
+| usage.rs:37:13:37:41 | GenericStruct {...} | regular.rs:36:1:39:1 | struct GenericStruct |
+| usage.rs:38:5:38:26 | x.generic_method(...) | regular.rs:50:5:50:37 | fn generic_method |
+| usage.rs:39:13:39:47 | GenericStruct {...} | regular.rs:36:1:39:1 | struct GenericStruct |
+| usage.rs:40:5:40:23 | x.generic_method(...) | regular.rs:54:5:54:39 | fn generic_method |
+| usage.rs:41:13:41:30 | GenericTupleStruct | regular.rs:41:1:41:50 | struct GenericTupleStruct |
+| usage.rs:42:5:42:26 | x.generic_method(...) | regular.rs:58:5:58:37 | fn generic_method |
+| usage.rs:43:13:43:30 | GenericTupleStruct | regular.rs:41:1:41:50 | struct GenericTupleStruct |
+| usage.rs:44:5:44:23 | x.generic_method(...) | regular.rs:62:5:62:39 | fn generic_method |
+| usage.rs:45:13:45:37 | ...::T | regular.rs:45:5:45:8 | T |
+| usage.rs:46:5:46:27 | x.generic_method(...) | regular.rs:66:5:66:37 | fn generic_method |
+| usage.rs:47:13:47:37 | ...::U | regular.rs:46:5:46:8 | U |
+| usage.rs:48:5:48:23 | x.generic_method(...) | regular.rs:70:5:70:39 | fn generic_method |
+| usage.rs:52:5:52:10 | ... .f(...) | regular.rs:74:5:74:18 | fn f |
+| usage.rs:53:5:53:15 | ... .f(...) | regular.rs:78:5:78:18 | fn f |
+| usage.rs:54:5:54:32 | ... .f(...) | regular.rs:82:5:82:18 | fn f |
+| usage.rs:55:5:55:16 | ... .f(...) | regular.rs:86:5:86:18 | fn f |
+| usage.rs:56:5:56:20 | ... .f(...) | regular.rs:90:5:90:18 | fn f |
+| usage.rs:60:43:60:60 | ...::new | regular.rs:98:5:100:5 | fn new |
diff --git a/rust/ql/test/extractor-tests/canonical_path/canonical_paths.ql b/rust/ql/test/extractor-tests/canonical_path/canonical_paths.ql
index 7488d699087c..484dbedfaf42 100644
--- a/rust/ql/test/extractor-tests/canonical_path/canonical_paths.ql
+++ b/rust/ql/test/extractor-tests/canonical_path/canonical_paths.ql
@@ -1,30 +1,41 @@
 import rust
 import TestUtils
 
-query predicate canonicalPaths(Item i, string origin, string path) {
+query predicate canonicalPaths(Addressable i, string answer, string cls) {
   toBeTested(i) and
   (
-    origin = i.getCrateOrigin()
+    exists(CanonicalPath p |
+      p = i.getCanonicalPath() and answer = p.toString() and cls = p.getPrimaryQlClasses()
+    )
     or
-    not i.hasCrateOrigin() and origin = "None"
-  ) and
-  (
-    path = i.getExtendedCanonicalPath()
-    or
-    not i.hasExtendedCanonicalPath() and path = "None"
+    not i.hasCanonicalPath() and answer = "None" and cls = ""
   )
 }
 
-query predicate resolvedPaths(Resolvable e, string origin, string path) {
-  toBeTested(e) and
+query predicate resolvedPaths(Resolvable i, string answer, string cls) {
+  toBeTested(i) and
   (
-    origin = e.getResolvedCrateOrigin()
+    exists(CanonicalPath p |
+      p = i.getResolvedCanonicalPath() and answer = p.toString() and cls = p.getPrimaryQlClasses()
+    )
     or
-    not e.hasResolvedCrateOrigin() and origin = "None"
-  ) and
-  (
-    path = e.getResolvedPath()
+    not i.hasResolvedCanonicalPath() and answer = "None" and cls = ""
+  )
+}
+
+query predicate standardPaths(Addressable i, string answer) {
+  toBeTested(i) and
+  exists(string namespace, string name |
+    i.hasStandardPath(namespace, name) and answer = namespace + "::" + name
     or
-    not e.hasResolvedPath() and path = "None"
+    exists(string type |
+      i.hasStandardPath(namespace, type, name) and answer = namespace + "::" + type + "::" + name
+    )
   )
 }
+
+query predicate resolve(Resolvable i, Addressable j) {
+  toBeTested(i) and
+  toBeTested(j) and
+  i.getResolvedCanonicalPath() = j.getCanonicalPath()
+}
diff --git a/rust/ql/test/extractor-tests/canonical_path/regular.rs b/rust/ql/test/extractor-tests/canonical_path/regular.rs
index 82b0525489fb..25ee02ef9ab2 100644
--- a/rust/ql/test/extractor-tests/canonical_path/regular.rs
+++ b/rust/ql/test/extractor-tests/canonical_path/regular.rs
@@ -10,10 +10,10 @@ impl Trait for Struct {
 }
 
 impl Struct {
-    fn g(&self) {}
+    pub fn g(&self) {}
 }
 
-trait TraitWithBlanketImpl {
+pub trait TraitWithBlanketImpl {
     fn h(&self);
 }
 
@@ -21,43 +21,81 @@ impl<T: Eq> TraitWithBlanketImpl for T {
     fn h(&self) {}
 }
 
-fn free() {}
+pub fn free() {}
 
-fn usage() {
-    let s = Struct {};
-    s.f();
-    s.g();
-    s.h();
-    free();
-}
-
-enum MyEnum {
+pub enum MyEnum {
     Variant1,
     Variant2(usize),
     Variant3 { x: usize },
 }
 
-fn enum_qualified_usage() {
-    _ = Option::None::<()>;
-    _ = Option::Some(0);
-    _ = MyEnum::Variant1;
-    _ = MyEnum::Variant2(0);
-    _ = MyEnum::Variant3 { x: 1 };
+pub trait GenericTrait<T> {
+    fn generic_method(&self, t: T);
+}
+
+pub struct GenericStruct<T, U> {
+    pub t: T,
+    pub u: U,
+}
+
+pub struct GenericTupleStruct<T, U>(pub T, pub U);
+
+
+pub enum GenericEnum<T, U> {
+    T(T),
+    U(U),
+}
+
+impl<T> GenericTrait<T> for GenericStruct<i32, T> {
+    fn generic_method(&self, t: T) {}
+}
+
+impl GenericTrait<i32> for GenericStruct<&str, i32> {
+    fn generic_method(&self, t: i32) {}
+}
+
+impl<T> GenericTrait<T> for GenericTupleStruct<i32, T> {
+    fn generic_method(&self, t: T) {}
+}
+
+impl GenericTrait<i32> for GenericTupleStruct<&str, i32> {
+    fn generic_method(&self, t: i32) {}
+}
+
+impl<T> GenericTrait<T> for GenericEnum<i32, T> {
+    fn generic_method(&self, t: T) {}
+}
+
+impl GenericTrait<i32> for GenericEnum<&str, i32> {
+    fn generic_method(&self, t: i32) {}
+}
+
+impl Trait for () {
+    fn f(&self) {}
+}
+
+impl Trait for (i32, &str) {
+    fn f(&self) {}
+}
+
+impl Trait for [i32] {
+    fn f(&self) {}
+}
+
+impl Trait for [&str; 2] {
+    fn f(&self) {}
+}
+
+impl Trait for [&str; 3] {
+    fn f(&self) {}
 }
 
-fn enum_unqualified_usage() {
-    _ = None::<()>;
-    _ = Some(0);
-    use MyEnum::*;
-    _ = Variant1;
-    _ = Variant2(0);
-    _ = Variant3 { x: 1 };
+pub trait TraitWithNew {
+    fn new() -> Self;
 }
 
-fn enum_match(e: MyEnum) {
-    match e {
-        MyEnum::Variant1 => {}
-        MyEnum::Variant2(_) => {}
-        MyEnum::Variant3 { .. } => {}
+impl<T: Default, U: Default> TraitWithNew for GenericStruct<T, U> {
+    fn new() -> Self {
+        GenericStruct{t: Default::default(), u: Default::default()}
     }
 }
diff --git a/rust/ql/test/extractor-tests/canonical_path/usage.rs b/rust/ql/test/extractor-tests/canonical_path/usage.rs
new file mode 100644
index 000000000000..90bb95ede574
--- /dev/null
+++ b/rust/ql/test/extractor-tests/canonical_path/usage.rs
@@ -0,0 +1,61 @@
+use crate::regular::*;
+
+fn usage() {
+    let s = Struct {};
+    s.f();
+    s.g();
+    s.h();
+    free();
+}
+
+fn enum_qualified_usage() {
+    _ = Option::None::<()>;
+    _ = Option::Some(0);
+    _ = MyEnum::Variant1;
+    _ = MyEnum::Variant2(0);
+    _ = MyEnum::Variant3 { x: 1 };
+}
+
+fn enum_unqualified_usage() {
+    _ = None::<()>;
+    _ = Some(0);
+    use MyEnum::*;
+    _ = Variant1;
+    _ = Variant2(0);
+    _ = Variant3 { x: 1 };
+}
+
+fn enum_match(e: MyEnum) {
+    match e {
+        MyEnum::Variant1 => {}
+        MyEnum::Variant2(_) => {}
+        MyEnum::Variant3 { .. } => {}
+    }
+}
+
+fn generic_usage() {
+    let x = GenericStruct { t: 0, u: "" };
+    x.generic_method("hi");
+    let x = GenericStruct { t: "hello", u: 42 };
+    x.generic_method(0);
+    let x = GenericTupleStruct(0, "");
+    x.generic_method("hi");
+    let x = GenericTupleStruct("hello", 42);
+    x.generic_method(0);
+    let x = GenericEnum::<_, &str>::T(0);
+    x.generic_method("hey");
+    let x = GenericEnum::<&str, _>::U(0);
+    x.generic_method(1);
+}
+
+fn use_trait() {
+    ().f();
+    (0, "").f();
+    vec![0, 1, 2].as_slice().f();
+    ["", ""].f();
+    ["", "", ""].f();
+}
+
+fn use_trait_with_new() {
+    let x: GenericStruct<usize, String> = GenericStruct::new();
+}
diff --git a/rust/ql/test/extractor-tests/generated/Const/Const.ql b/rust/ql/test/extractor-tests/generated/Const/Const.ql
index f1509aac3689..9f2654cdf6fe 100644
--- a/rust/ql/test/extractor-tests/generated/Const/Const.ql
+++ b/rust/ql/test/extractor-tests/generated/Const/Const.ql
@@ -3,18 +3,12 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Const x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasBody, string isConst, string isDefault, string hasName, string hasTypeRepr,
-  string hasVisibility
+  Const x, string hasCanonicalPath, int getNumberOfAttrs, string hasBody, string isConst,
+  string isDefault, string hasName, string hasTypeRepr, string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasBody() then hasBody = "yes" else hasBody = "no") and
   (if x.isConst() then isConst = "yes" else isConst = "no") and
@@ -22,6 +16,6 @@ where
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasTypeRepr() then hasTypeRepr = "yes" else hasTypeRepr = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasBody:", hasBody, "isConst:", isConst, "isDefault:",
-  isDefault, "hasName:", hasName, "hasTypeRepr:", hasTypeRepr, "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs, "hasBody:",
+  hasBody, "isConst:", isConst, "isDefault:", isDefault, "hasName:", hasName, "hasTypeRepr:",
+  hasTypeRepr, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/Const/Const_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Const/Const_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Const/Const_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Const/Const_getCanonicalPath.ql
index 644b92409802..ca35b81c3563 100644
--- a/rust/ql/test/extractor-tests/generated/Const/Const_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Const/Const_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Const x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Const/Const_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Const/Const_getExtendedCanonicalPath.ql
deleted file mode 100644
index c11c4e0856d7..000000000000
--- a/rust/ql/test/extractor-tests/generated/Const/Const_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Const x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Enum/Enum.ql b/rust/ql/test/extractor-tests/generated/Enum/Enum.ql
index 3468056c072b..14daec3dc894 100644
--- a/rust/ql/test/extractor-tests/generated/Enum/Enum.ql
+++ b/rust/ql/test/extractor-tests/generated/Enum/Enum.ql
@@ -3,25 +3,18 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Enum x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasGenericParamList, string hasName, string hasVariantList, string hasVisibility,
-  string hasWhereClause
+  Enum x, string hasCanonicalPath, int getNumberOfAttrs, string hasGenericParamList, string hasName,
+  string hasVariantList, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasVariantList() then hasVariantList = "yes" else hasVariantList = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "hasName:",
-  hasName, "hasVariantList:", hasVariantList, "hasVisibility:", hasVisibility, "hasWhereClause:",
-  hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasGenericParamList:", hasGenericParamList, "hasName:", hasName, "hasVariantList:",
+  hasVariantList, "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Enum/Enum_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Enum/Enum_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Enum/Enum_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Enum/Enum_getCanonicalPath.ql
index 07fdc2fe5cde..cee285ae0920 100644
--- a/rust/ql/test/extractor-tests/generated/Enum/Enum_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Enum/Enum_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Enum x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Enum/Enum_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Enum/Enum_getExtendedCanonicalPath.ql
deleted file mode 100644
index fa456ecd9d03..000000000000
--- a/rust/ql/test/extractor-tests/generated/Enum/Enum_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Enum x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock.ql b/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock.ql
index 3d58a4714123..da83b20973d8 100644
--- a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock.ql
+++ b/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock.ql
@@ -3,21 +3,15 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  ExternBlock x, string hasExtendedCanonicalPath, string hasCrateOrigin, string hasAbi,
-  int getNumberOfAttrs, string hasExternItemList, string isUnsafe
+  ExternBlock x, string hasCanonicalPath, string hasAbi, int getNumberOfAttrs,
+  string hasExternItemList, string isUnsafe
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   (if x.hasAbi() then hasAbi = "yes" else hasAbi = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasExternItemList() then hasExternItemList = "yes" else hasExternItemList = "no") and
   if x.isUnsafe() then isUnsafe = "yes" else isUnsafe = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "hasAbi:", hasAbi, "getNumberOfAttrs:", getNumberOfAttrs, "hasExternItemList:", hasExternItemList,
-  "isUnsafe:", isUnsafe
+select x, "hasCanonicalPath:", hasCanonicalPath, "hasAbi:", hasAbi, "getNumberOfAttrs:",
+  getNumberOfAttrs, "hasExternItemList:", hasExternItemList, "isUnsafe:", isUnsafe
diff --git a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCanonicalPath.ql
index 5be455fe7d24..54923d7dbb4e 100644
--- a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from ExternBlock x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getExtendedCanonicalPath.ql
deleted file mode 100644
index f0bd607a179a..000000000000
--- a/rust/ql/test/extractor-tests/generated/ExternBlock/ExternBlock_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from ExternBlock x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate.ql b/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate.ql
index 547a20808643..7217843c0036 100644
--- a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate.ql
+++ b/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate.ql
@@ -3,21 +3,15 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  ExternCrate x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasNameRef, string hasRename, string hasVisibility
+  ExternCrate x, string hasCanonicalPath, int getNumberOfAttrs, string hasNameRef, string hasRename,
+  string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasNameRef() then hasNameRef = "yes" else hasNameRef = "no") and
   (if x.hasRename() then hasRename = "yes" else hasRename = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasNameRef:", hasNameRef, "hasRename:", hasRename,
-  "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasNameRef:", hasNameRef, "hasRename:", hasRename, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCanonicalPath.ql
index b6b74730fe40..1ef1af7c81d2 100644
--- a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from ExternCrate x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getExtendedCanonicalPath.ql
deleted file mode 100644
index 15959426eed0..000000000000
--- a/rust/ql/test/extractor-tests/generated/ExternCrate/ExternCrate_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from ExternCrate x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Function/Function.ql b/rust/ql/test/extractor-tests/generated/Function/Function.ql
index a6e969111fb9..f19d20684a19 100644
--- a/rust/ql/test/extractor-tests/generated/Function/Function.ql
+++ b/rust/ql/test/extractor-tests/generated/Function/Function.ql
@@ -3,21 +3,16 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Function x, string hasParamList, int getNumberOfAttrs, string hasExtendedCanonicalPath,
-  string hasCrateOrigin, string hasAbi, string hasBody, string hasGenericParamList, string isAsync,
-  string isConst, string isDefault, string isGen, string isUnsafe, string hasName,
-  string hasRetType, string hasVisibility, string hasWhereClause
+  Function x, string hasParamList, int getNumberOfAttrs, string hasCanonicalPath, string hasAbi,
+  string hasBody, string hasGenericParamList, string isAsync, string isConst, string isDefault,
+  string isGen, string isUnsafe, string hasName, string hasRetType, string hasVisibility,
+  string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
   (if x.hasParamList() then hasParamList = "yes" else hasParamList = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   (if x.hasAbi() then hasAbi = "yes" else hasAbi = "no") and
   (if x.hasBody() then hasBody = "yes" else hasBody = "no") and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
@@ -30,9 +25,8 @@ where
   (if x.hasRetType() then hasRetType = "yes" else hasRetType = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasParamList:", hasParamList, "getNumberOfAttrs:", getNumberOfAttrs,
-  "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "hasAbi:", hasAbi, "hasBody:", hasBody, "hasGenericParamList:", hasGenericParamList, "isAsync:",
-  isAsync, "isConst:", isConst, "isDefault:", isDefault, "isGen:", isGen, "isUnsafe:", isUnsafe,
-  "hasName:", hasName, "hasRetType:", hasRetType, "hasVisibility:", hasVisibility,
-  "hasWhereClause:", hasWhereClause
+select x, "hasParamList:", hasParamList, "getNumberOfAttrs:", getNumberOfAttrs, "hasCanonicalPath:",
+  hasCanonicalPath, "hasAbi:", hasAbi, "hasBody:", hasBody, "hasGenericParamList:",
+  hasGenericParamList, "isAsync:", isAsync, "isConst:", isConst, "isDefault:", isDefault, "isGen:",
+  isGen, "isUnsafe:", isUnsafe, "hasName:", hasName, "hasRetType:", hasRetType, "hasVisibility:",
+  hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Function/Function_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Function/Function_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Function/Function_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Function/Function_getCanonicalPath.ql
index 933e5867d841..e89d26f15eb2 100644
--- a/rust/ql/test/extractor-tests/generated/Function/Function_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Function/Function_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Function x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Function/Function_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Function/Function_getExtendedCanonicalPath.ql
deleted file mode 100644
index f2c413748de6..000000000000
--- a/rust/ql/test/extractor-tests/generated/Function/Function_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Function x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Impl/Impl.ql b/rust/ql/test/extractor-tests/generated/Impl/Impl.ql
index 5af0d0da0d44..ed3cabc467a7 100644
--- a/rust/ql/test/extractor-tests/generated/Impl/Impl.ql
+++ b/rust/ql/test/extractor-tests/generated/Impl/Impl.ql
@@ -3,18 +3,13 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Impl x, string hasExtendedCanonicalPath, string hasCrateOrigin, string hasAssocItemList,
-  int getNumberOfAttrs, string hasGenericParamList, string isConst, string isDefault,
-  string isUnsafe, string hasSelfTy, string hasTrait, string hasVisibility, string hasWhereClause
+  Impl x, string hasCanonicalPath, string hasAssocItemList, int getNumberOfAttrs,
+  string hasGenericParamList, string isConst, string isDefault, string isUnsafe, string hasSelfTy,
+  string hasTrait, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   (if x.hasAssocItemList() then hasAssocItemList = "yes" else hasAssocItemList = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
@@ -25,8 +20,7 @@ where
   (if x.hasTrait() then hasTrait = "yes" else hasTrait = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "hasAssocItemList:", hasAssocItemList, "getNumberOfAttrs:", getNumberOfAttrs,
-  "hasGenericParamList:", hasGenericParamList, "isConst:", isConst, "isDefault:", isDefault,
-  "isUnsafe:", isUnsafe, "hasSelfTy:", hasSelfTy, "hasTrait:", hasTrait, "hasVisibility:",
-  hasVisibility, "hasWhereClause:", hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "hasAssocItemList:", hasAssocItemList,
+  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "isConst:",
+  isConst, "isDefault:", isDefault, "isUnsafe:", isUnsafe, "hasSelfTy:", hasSelfTy, "hasTrait:",
+  hasTrait, "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Impl/Impl_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Impl/Impl_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Impl/Impl_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Impl/Impl_getCanonicalPath.ql
index b9d428ce94aa..d6472f9faf92 100644
--- a/rust/ql/test/extractor-tests/generated/Impl/Impl_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Impl/Impl_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Impl x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Impl/Impl_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Impl/Impl_getExtendedCanonicalPath.ql
deleted file mode 100644
index 140490fcaff3..000000000000
--- a/rust/ql/test/extractor-tests/generated/Impl/Impl_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Impl x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall.ql b/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall.ql
index 56044c127c26..8966bc866e37 100644
--- a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall.ql
@@ -3,21 +3,15 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  MacroCall x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasPath, string hasTokenTree, string hasExpanded
+  MacroCall x, string hasCanonicalPath, int getNumberOfAttrs, string hasPath, string hasTokenTree,
+  string hasExpanded
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasPath() then hasPath = "yes" else hasPath = "no") and
   (if x.hasTokenTree() then hasTokenTree = "yes" else hasTokenTree = "no") and
   if x.hasExpanded() then hasExpanded = "yes" else hasExpanded = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasPath:", hasPath, "hasTokenTree:", hasTokenTree,
-  "hasExpanded:", hasExpanded
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs, "hasPath:",
+  hasPath, "hasTokenTree:", hasTokenTree, "hasExpanded:", hasExpanded
diff --git a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCanonicalPath.ql
index 60e32669e7fc..bb93fbca8979 100644
--- a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from MacroCall x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getExtendedCanonicalPath.ql
deleted file mode 100644
index 0fffb4f4384e..000000000000
--- a/rust/ql/test/extractor-tests/generated/MacroCall/MacroCall_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from MacroCall x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef.ql b/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef.ql
index 957d5b9ea9ee..f5cc4fb31175 100644
--- a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef.ql
@@ -3,22 +3,16 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  MacroDef x, string hasExtendedCanonicalPath, string hasCrateOrigin, string hasArgs,
-  int getNumberOfAttrs, string hasBody, string hasName, string hasVisibility
+  MacroDef x, string hasCanonicalPath, string hasArgs, int getNumberOfAttrs, string hasBody,
+  string hasName, string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   (if x.hasArgs() then hasArgs = "yes" else hasArgs = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasBody() then hasBody = "yes" else hasBody = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "hasArgs:", hasArgs, "getNumberOfAttrs:", getNumberOfAttrs, "hasBody:", hasBody, "hasName:",
-  hasName, "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "hasArgs:", hasArgs, "getNumberOfAttrs:",
+  getNumberOfAttrs, "hasBody:", hasBody, "hasName:", hasName, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCanonicalPath.ql
index 81aa4aa3fadc..ecf2dd2c24cb 100644
--- a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from MacroDef x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getExtendedCanonicalPath.ql
deleted file mode 100644
index c30de43e669c..000000000000
--- a/rust/ql/test/extractor-tests/generated/MacroDef/MacroDef_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from MacroDef x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules.ql b/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules.ql
index 7bdc462c01cd..ee225a710384 100644
--- a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules.ql
@@ -3,21 +3,15 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  MacroRules x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasName, string hasTokenTree, string hasVisibility
+  MacroRules x, string hasCanonicalPath, int getNumberOfAttrs, string hasName, string hasTokenTree,
+  string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasTokenTree() then hasTokenTree = "yes" else hasTokenTree = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasName:", hasName, "hasTokenTree:", hasTokenTree,
-  "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs, "hasName:",
+  hasName, "hasTokenTree:", hasTokenTree, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCanonicalPath.ql
index 987a91f57068..be2591d73b4c 100644
--- a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from MacroRules x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getExtendedCanonicalPath.ql
deleted file mode 100644
index b2fa0cc9f7e9..000000000000
--- a/rust/ql/test/extractor-tests/generated/MacroRules/MacroRules_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from MacroRules x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql b/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql
index 989540265a00..d3b5692c874e 100644
--- a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql
+++ b/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr.ql
@@ -3,22 +3,21 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  MethodCallExpr x, string hasArgList, int getNumberOfAttrs, string hasResolvedPath,
-  string hasResolvedCrateOrigin, string hasGenericArgList, string hasNameRef, string hasReceiver
+  MethodCallExpr x, string hasArgList, int getNumberOfAttrs, string hasResolvedCanonicalPath,
+  string hasGenericArgList, string hasNameRef, string hasReceiver
 where
   toBeTested(x) and
   not x.isUnknown() and
   (if x.hasArgList() then hasArgList = "yes" else hasArgList = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   (if x.hasGenericArgList() then hasGenericArgList = "yes" else hasGenericArgList = "no") and
   (if x.hasNameRef() then hasNameRef = "yes" else hasNameRef = "no") and
   if x.hasReceiver() then hasReceiver = "yes" else hasReceiver = "no"
-select x, "hasArgList:", hasArgList, "getNumberOfAttrs:", getNumberOfAttrs, "hasResolvedPath:",
-  hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin, "hasGenericArgList:",
-  hasGenericArgList, "hasNameRef:", hasNameRef, "hasReceiver:", hasReceiver
+select x, "hasArgList:", hasArgList, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasGenericArgList:", hasGenericArgList,
+  "hasNameRef:", hasNameRef, "hasReceiver:", hasReceiver
diff --git a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCanonicalPath.ql
similarity index 79%
rename from rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCanonicalPath.ql
index dfb292181331..eed44cb701bb 100644
--- a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from MethodCallExpr x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedPath.ql
deleted file mode 100644
index df94686cbf68..000000000000
--- a/rust/ql/test/extractor-tests/generated/MethodCallExpr/MethodCallExpr_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from MethodCallExpr x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/Module/Module.ql b/rust/ql/test/extractor-tests/generated/Module/Module.ql
index a33b7daa8954..52c9b581d307 100644
--- a/rust/ql/test/extractor-tests/generated/Module/Module.ql
+++ b/rust/ql/test/extractor-tests/generated/Module/Module.ql
@@ -3,21 +3,15 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Module x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasItemList, string hasName, string hasVisibility
+  Module x, string hasCanonicalPath, int getNumberOfAttrs, string hasItemList, string hasName,
+  string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasItemList() then hasItemList = "yes" else hasItemList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasItemList:", hasItemList, "hasName:", hasName,
-  "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasItemList:", hasItemList, "hasName:", hasName, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/Module/Module_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Module/Module_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Module/Module_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Module/Module_getCanonicalPath.ql
index 7a95cdcc772a..739c7333e99f 100644
--- a/rust/ql/test/extractor-tests/generated/Module/Module_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Module/Module_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Module x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Module/Module_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Module/Module_getExtendedCanonicalPath.ql
deleted file mode 100644
index 9c810fe65c67..000000000000
--- a/rust/ql/test/extractor-tests/generated/Module/Module_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Module x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathExpr.expected b/rust/ql/test/extractor-tests/generated/Path/PathExpr.expected
index 25bc95ed055b..1817be29e349 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathExpr.expected
+++ b/rust/ql/test/extractor-tests/generated/Path/PathExpr.expected
@@ -1,6 +1,6 @@
-| gen_path.rs:6:5:6:12 | ...::bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
-| gen_path_expr.rs:5:13:5:20 | variable | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
-| gen_path_expr.rs:6:13:6:20 | ...::bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
-| gen_path_expr.rs:7:13:7:20 | ...::foo | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
-| gen_path_expr.rs:8:13:8:36 | ...::foo | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
-| gen_path_pat.rs:5:11:5:11 | x | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path.rs:6:5:6:12 | ...::bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path_expr.rs:5:13:5:20 | variable | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path_expr.rs:6:13:6:20 | ...::bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path_expr.rs:7:13:7:20 | ...::foo | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path_expr.rs:8:13:8:36 | ...::foo | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
+| gen_path_pat.rs:5:11:5:11 | x | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes | getNumberOfAttrs: | 0 |
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathExpr.ql b/rust/ql/test/extractor-tests/generated/Path/PathExpr.ql
index 41b7414d24c7..79c7a9aca164 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathExpr.ql
+++ b/rust/ql/test/extractor-tests/generated/Path/PathExpr.ql
@@ -2,19 +2,16 @@
 import codeql.rust.elements
 import TestUtils
 
-from
-  PathExpr x, string hasResolvedPath, string hasResolvedCrateOrigin, string hasPath,
-  int getNumberOfAttrs
+from PathExpr x, string hasResolvedCanonicalPath, string hasPath, int getNumberOfAttrs
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   (if x.hasPath() then hasPath = "yes" else hasPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs()
-select x, "hasResolvedPath:", hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin,
-  "hasPath:", hasPath, "getNumberOfAttrs:", getNumberOfAttrs
+select x, "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasPath:", hasPath,
+  "getNumberOfAttrs:", getNumberOfAttrs
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.expected b/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.expected
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.ql
similarity index 78%
rename from rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.ql
index 24e079184844..7a99c6e6c156 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from PathExpr x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedPath.ql
deleted file mode 100644
index 10e6ceb2a0b9..000000000000
--- a/rust/ql/test/extractor-tests/generated/Path/PathExpr_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from PathExpr x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathPat.expected b/rust/ql/test/extractor-tests/generated/Path/PathPat.expected
index cf90175a84c0..0f5147409297 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathPat.expected
+++ b/rust/ql/test/extractor-tests/generated/Path/PathPat.expected
@@ -1 +1 @@
-| gen_path_pat.rs:6:9:6:16 | ...::Bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasPath: | yes |
+| gen_path_pat.rs:6:9:6:16 | ...::Bar | hasResolvedPath: | no | hasResolvedCrateOrigin: | no | hasResolvedCanonicalPath: | no | hasPath: | yes |
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathPat.ql b/rust/ql/test/extractor-tests/generated/Path/PathPat.ql
index a105c20c39ed..60a868601147 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathPat.ql
+++ b/rust/ql/test/extractor-tests/generated/Path/PathPat.ql
@@ -2,16 +2,14 @@
 import codeql.rust.elements
 import TestUtils
 
-from PathPat x, string hasResolvedPath, string hasResolvedCrateOrigin, string hasPath
+from PathPat x, string hasResolvedCanonicalPath, string hasPath
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   if x.hasPath() then hasPath = "yes" else hasPath = "no"
-select x, "hasResolvedPath:", hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin,
-  "hasPath:", hasPath
+select x, "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasPath:", hasPath
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.expected b/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.expected
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.ql
similarity index 78%
rename from rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.ql
index 7ed41155d77e..025249decc7a 100644
--- a/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from PathPat x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedPath.ql
deleted file mode 100644
index cbe1932925a8..000000000000
--- a/rust/ql/test/extractor-tests/generated/Path/PathPat_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from PathPat x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr.ql b/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr.ql
index 56c14f27dfdf..c13d7a922a09 100644
--- a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr.ql
+++ b/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr.ql
@@ -2,21 +2,18 @@
 import codeql.rust.elements
 import TestUtils
 
-from
-  RecordExpr x, string hasResolvedPath, string hasResolvedCrateOrigin, string hasPath,
-  string hasRecordExprFieldList
+from RecordExpr x, string hasResolvedCanonicalPath, string hasPath, string hasRecordExprFieldList
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   (if x.hasPath() then hasPath = "yes" else hasPath = "no") and
   if x.hasRecordExprFieldList()
   then hasRecordExprFieldList = "yes"
   else hasRecordExprFieldList = "no"
-select x, "hasResolvedPath:", hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin,
-  "hasPath:", hasPath, "hasRecordExprFieldList:", hasRecordExprFieldList
+select x, "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasPath:", hasPath,
+  "hasRecordExprFieldList:", hasRecordExprFieldList
diff --git a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCanonicalPath.ql
similarity index 78%
rename from rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCanonicalPath.ql
index 25635cb050f9..e904b317c119 100644
--- a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from RecordExpr x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedPath.ql
deleted file mode 100644
index 0f3230f3314a..000000000000
--- a/rust/ql/test/extractor-tests/generated/RecordExpr/RecordExpr_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from RecordExpr x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat.ql b/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat.ql
index 3b0797773068..21083f334467 100644
--- a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat.ql
+++ b/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat.ql
@@ -2,19 +2,16 @@
 import codeql.rust.elements
 import TestUtils
 
-from
-  RecordPat x, string hasResolvedPath, string hasResolvedCrateOrigin, string hasPath,
-  string hasRecordPatFieldList
+from RecordPat x, string hasResolvedCanonicalPath, string hasPath, string hasRecordPatFieldList
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   (if x.hasPath() then hasPath = "yes" else hasPath = "no") and
   if x.hasRecordPatFieldList() then hasRecordPatFieldList = "yes" else hasRecordPatFieldList = "no"
-select x, "hasResolvedPath:", hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin,
-  "hasPath:", hasPath, "hasRecordPatFieldList:", hasRecordPatFieldList
+select x, "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasPath:", hasPath,
+  "hasRecordPatFieldList:", hasRecordPatFieldList
diff --git a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCanonicalPath.ql
similarity index 78%
rename from rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCanonicalPath.ql
index f80865d05157..614a6e34196d 100644
--- a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from RecordPat x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedPath.ql
deleted file mode 100644
index a816942e47b5..000000000000
--- a/rust/ql/test/extractor-tests/generated/RecordPat/RecordPat_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from RecordPat x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/Static/Static.ql b/rust/ql/test/extractor-tests/generated/Static/Static.ql
index 3a632dabf47c..c57b98ae77c1 100644
--- a/rust/ql/test/extractor-tests/generated/Static/Static.ql
+++ b/rust/ql/test/extractor-tests/generated/Static/Static.ql
@@ -3,18 +3,12 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Static x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasBody, string isMut, string isStatic, string hasName, string hasTypeRepr,
-  string hasVisibility
+  Static x, string hasCanonicalPath, int getNumberOfAttrs, string hasBody, string isMut,
+  string isStatic, string hasName, string hasTypeRepr, string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasBody() then hasBody = "yes" else hasBody = "no") and
   (if x.isMut() then isMut = "yes" else isMut = "no") and
@@ -22,6 +16,6 @@ where
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasTypeRepr() then hasTypeRepr = "yes" else hasTypeRepr = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasBody:", hasBody, "isMut:", isMut, "isStatic:",
-  isStatic, "hasName:", hasName, "hasTypeRepr:", hasTypeRepr, "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs, "hasBody:",
+  hasBody, "isMut:", isMut, "isStatic:", isStatic, "hasName:", hasName, "hasTypeRepr:", hasTypeRepr,
+  "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/Static/Static_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Static/Static_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Static/Static_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Static/Static_getCanonicalPath.ql
index 373b6bd45f42..f4ee3ee90697 100644
--- a/rust/ql/test/extractor-tests/generated/Static/Static_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Static/Static_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Static x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Static/Static_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Static/Static_getExtendedCanonicalPath.ql
deleted file mode 100644
index 32b3a0c127e1..000000000000
--- a/rust/ql/test/extractor-tests/generated/Static/Static_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Static x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Struct/Struct.ql b/rust/ql/test/extractor-tests/generated/Struct/Struct.ql
index d2b3a349386c..84bd193a7e02 100644
--- a/rust/ql/test/extractor-tests/generated/Struct/Struct.ql
+++ b/rust/ql/test/extractor-tests/generated/Struct/Struct.ql
@@ -3,25 +3,18 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Struct x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasFieldList, string hasGenericParamList, string hasName, string hasVisibility,
-  string hasWhereClause
+  Struct x, string hasCanonicalPath, int getNumberOfAttrs, string hasFieldList,
+  string hasGenericParamList, string hasName, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasFieldList() then hasFieldList = "yes" else hasFieldList = "no") and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasFieldList:", hasFieldList, "hasGenericParamList:",
-  hasGenericParamList, "hasName:", hasName, "hasVisibility:", hasVisibility, "hasWhereClause:",
-  hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasFieldList:", hasFieldList, "hasGenericParamList:", hasGenericParamList, "hasName:", hasName,
+  "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Struct/Struct_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Struct/Struct_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Struct/Struct_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Struct/Struct_getCanonicalPath.ql
index cafe120d4dec..59cda44eff73 100644
--- a/rust/ql/test/extractor-tests/generated/Struct/Struct_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Struct/Struct_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Struct x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Struct/Struct_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Struct/Struct_getExtendedCanonicalPath.ql
deleted file mode 100644
index f502a347b3e7..000000000000
--- a/rust/ql/test/extractor-tests/generated/Struct/Struct_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Struct x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Trait/Trait.ql b/rust/ql/test/extractor-tests/generated/Trait/Trait.ql
index b4548cddceee..e2793868b074 100644
--- a/rust/ql/test/extractor-tests/generated/Trait/Trait.ql
+++ b/rust/ql/test/extractor-tests/generated/Trait/Trait.ql
@@ -3,18 +3,13 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Trait x, string hasExtendedCanonicalPath, string hasCrateOrigin, string hasAssocItemList,
-  int getNumberOfAttrs, string hasGenericParamList, string isAuto, string isUnsafe, string hasName,
+  Trait x, string hasCanonicalPath, string hasAssocItemList, int getNumberOfAttrs,
+  string hasGenericParamList, string isAuto, string isUnsafe, string hasName,
   string hasTypeBoundList, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   (if x.hasAssocItemList() then hasAssocItemList = "yes" else hasAssocItemList = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
@@ -24,8 +19,7 @@ where
   (if x.hasTypeBoundList() then hasTypeBoundList = "yes" else hasTypeBoundList = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "hasAssocItemList:", hasAssocItemList, "getNumberOfAttrs:", getNumberOfAttrs,
-  "hasGenericParamList:", hasGenericParamList, "isAuto:", isAuto, "isUnsafe:", isUnsafe, "hasName:",
-  hasName, "hasTypeBoundList:", hasTypeBoundList, "hasVisibility:", hasVisibility,
-  "hasWhereClause:", hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "hasAssocItemList:", hasAssocItemList,
+  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "isAuto:",
+  isAuto, "isUnsafe:", isUnsafe, "hasName:", hasName, "hasTypeBoundList:", hasTypeBoundList,
+  "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Trait/Trait_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Trait/Trait_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Trait/Trait_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Trait/Trait_getCanonicalPath.ql
index 8c2c71a918e4..96b8ef582c90 100644
--- a/rust/ql/test/extractor-tests/generated/Trait/Trait_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Trait/Trait_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Trait x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Trait/Trait_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Trait/Trait_getExtendedCanonicalPath.ql
deleted file mode 100644
index 5281a18656bd..000000000000
--- a/rust/ql/test/extractor-tests/generated/Trait/Trait_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Trait x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias.ql b/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias.ql
index 80fe86e27493..882c63ddfdb2 100644
--- a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias.ql
+++ b/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias.ql
@@ -3,25 +3,18 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  TraitAlias x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasGenericParamList, string hasName, string hasTypeBoundList, string hasVisibility,
-  string hasWhereClause
+  TraitAlias x, string hasCanonicalPath, int getNumberOfAttrs, string hasGenericParamList,
+  string hasName, string hasTypeBoundList, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasTypeBoundList() then hasTypeBoundList = "yes" else hasTypeBoundList = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "hasName:",
-  hasName, "hasTypeBoundList:", hasTypeBoundList, "hasVisibility:", hasVisibility,
-  "hasWhereClause:", hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasGenericParamList:", hasGenericParamList, "hasName:", hasName, "hasTypeBoundList:",
+  hasTypeBoundList, "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCanonicalPath.ql
index 6f9ccf89262d..90ae62e9f861 100644
--- a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from TraitAlias x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getExtendedCanonicalPath.ql
deleted file mode 100644
index 6326e730c331..000000000000
--- a/rust/ql/test/extractor-tests/generated/TraitAlias/TraitAlias_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from TraitAlias x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql b/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql
index af59101fe752..daffdd786d64 100644
--- a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql
+++ b/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat.ql
@@ -2,19 +2,16 @@
 import codeql.rust.elements
 import TestUtils
 
-from
-  TupleStructPat x, string hasResolvedPath, string hasResolvedCrateOrigin, string hasPath,
-  int getNumberOfFields
+from TupleStructPat x, string hasResolvedCanonicalPath, string hasPath, int getNumberOfFields
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (if x.hasResolvedPath() then hasResolvedPath = "yes" else hasResolvedPath = "no") and
   (
-    if x.hasResolvedCrateOrigin()
-    then hasResolvedCrateOrigin = "yes"
-    else hasResolvedCrateOrigin = "no"
+    if x.hasResolvedCanonicalPath()
+    then hasResolvedCanonicalPath = "yes"
+    else hasResolvedCanonicalPath = "no"
   ) and
   (if x.hasPath() then hasPath = "yes" else hasPath = "no") and
   getNumberOfFields = x.getNumberOfFields()
-select x, "hasResolvedPath:", hasResolvedPath, "hasResolvedCrateOrigin:", hasResolvedCrateOrigin,
-  "hasPath:", hasPath, "getNumberOfFields:", getNumberOfFields
+select x, "hasResolvedCanonicalPath:", hasResolvedCanonicalPath, "hasPath:", hasPath,
+  "getNumberOfFields:", getNumberOfFields
diff --git a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCanonicalPath.ql
similarity index 79%
rename from rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCanonicalPath.ql
index 144302946a94..c8adcabc253d 100644
--- a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from TupleStructPat x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedCrateOrigin()
+select x, x.getResolvedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedPath.ql b/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedPath.ql
deleted file mode 100644
index 561c303d9682..000000000000
--- a/rust/ql/test/extractor-tests/generated/TupleStructPat/TupleStructPat_getResolvedPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from TupleStructPat x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getResolvedPath()
diff --git a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias.ql b/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias.ql
index 16e92ed7e023..79f84c734267 100644
--- a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias.ql
+++ b/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias.ql
@@ -3,18 +3,13 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  TypeAlias x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasGenericParamList, string isDefault, string hasName, string hasTypeRepr,
-  string hasTypeBoundList, string hasVisibility, string hasWhereClause
+  TypeAlias x, string hasCanonicalPath, int getNumberOfAttrs, string hasGenericParamList,
+  string isDefault, string hasName, string hasTypeRepr, string hasTypeBoundList,
+  string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
   (if x.isDefault() then isDefault = "yes" else isDefault = "no") and
@@ -23,7 +18,7 @@ where
   (if x.hasTypeBoundList() then hasTypeBoundList = "yes" else hasTypeBoundList = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "isDefault:",
-  isDefault, "hasName:", hasName, "hasTypeRepr:", hasTypeRepr, "hasTypeBoundList:",
-  hasTypeBoundList, "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasGenericParamList:", hasGenericParamList, "isDefault:", isDefault, "hasName:", hasName,
+  "hasTypeRepr:", hasTypeRepr, "hasTypeBoundList:", hasTypeBoundList, "hasVisibility:",
+  hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCanonicalPath.ql
similarity index 82%
rename from rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCanonicalPath.ql
index 9a4de0cd9b85..a9a00151f764 100644
--- a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from TypeAlias x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getExtendedCanonicalPath.ql
deleted file mode 100644
index 1f99c7595567..000000000000
--- a/rust/ql/test/extractor-tests/generated/TypeAlias/TypeAlias_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from TypeAlias x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Union/Union.ql b/rust/ql/test/extractor-tests/generated/Union/Union.ql
index 0f0e0872d9d9..1366f0e093c3 100644
--- a/rust/ql/test/extractor-tests/generated/Union/Union.ql
+++ b/rust/ql/test/extractor-tests/generated/Union/Union.ql
@@ -3,25 +3,18 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Union x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasGenericParamList, string hasName, string hasRecordFieldList, string hasVisibility,
-  string hasWhereClause
+  Union x, string hasCanonicalPath, int getNumberOfAttrs, string hasGenericParamList,
+  string hasName, string hasRecordFieldList, string hasVisibility, string hasWhereClause
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasGenericParamList() then hasGenericParamList = "yes" else hasGenericParamList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   (if x.hasRecordFieldList() then hasRecordFieldList = "yes" else hasRecordFieldList = "no") and
   (if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no") and
   if x.hasWhereClause() then hasWhereClause = "yes" else hasWhereClause = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasGenericParamList:", hasGenericParamList, "hasName:",
-  hasName, "hasRecordFieldList:", hasRecordFieldList, "hasVisibility:", hasVisibility,
-  "hasWhereClause:", hasWhereClause
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasGenericParamList:", hasGenericParamList, "hasName:", hasName, "hasRecordFieldList:",
+  hasRecordFieldList, "hasVisibility:", hasVisibility, "hasWhereClause:", hasWhereClause
diff --git a/rust/ql/test/extractor-tests/generated/Union/Union_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Union/Union_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Union/Union_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Union/Union_getCanonicalPath.ql
index fdbd56d9e88f..7295625e8cc7 100644
--- a/rust/ql/test/extractor-tests/generated/Union/Union_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Union/Union_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Union x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Union/Union_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Union/Union_getExtendedCanonicalPath.ql
deleted file mode 100644
index fb20efa8f29e..000000000000
--- a/rust/ql/test/extractor-tests/generated/Union/Union_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Union x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Use/Use.ql b/rust/ql/test/extractor-tests/generated/Use/Use.ql
index b88b3a693322..8fd8e7e704a3 100644
--- a/rust/ql/test/extractor-tests/generated/Use/Use.ql
+++ b/rust/ql/test/extractor-tests/generated/Use/Use.ql
@@ -2,20 +2,13 @@
 import codeql.rust.elements
 import TestUtils
 
-from
-  Use x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasUseTree, string hasVisibility
+from Use x, string hasCanonicalPath, int getNumberOfAttrs, string hasUseTree, string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasUseTree() then hasUseTree = "yes" else hasUseTree = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasUseTree:", hasUseTree, "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs,
+  "hasUseTree:", hasUseTree, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/Use/Use_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Use/Use_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Use/Use_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Use/Use_getCanonicalPath.ql
index 8e90afcc335d..b42749f2c795 100644
--- a/rust/ql/test/extractor-tests/generated/Use/Use_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Use/Use_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Use x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Use/Use_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Use/Use_getExtendedCanonicalPath.ql
deleted file mode 100644
index 64c633c6c7d1..000000000000
--- a/rust/ql/test/extractor-tests/generated/Use/Use_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Use x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Variant/Variant.ql b/rust/ql/test/extractor-tests/generated/Variant/Variant.ql
index 92ebcbe55eed..8917b039fb86 100644
--- a/rust/ql/test/extractor-tests/generated/Variant/Variant.ql
+++ b/rust/ql/test/extractor-tests/generated/Variant/Variant.ql
@@ -3,22 +3,16 @@ import codeql.rust.elements
 import TestUtils
 
 from
-  Variant x, string hasExtendedCanonicalPath, string hasCrateOrigin, int getNumberOfAttrs,
-  string hasExpr, string hasFieldList, string hasName, string hasVisibility
+  Variant x, string hasCanonicalPath, int getNumberOfAttrs, string hasExpr, string hasFieldList,
+  string hasName, string hasVisibility
 where
   toBeTested(x) and
   not x.isUnknown() and
-  (
-    if x.hasExtendedCanonicalPath()
-    then hasExtendedCanonicalPath = "yes"
-    else hasExtendedCanonicalPath = "no"
-  ) and
-  (if x.hasCrateOrigin() then hasCrateOrigin = "yes" else hasCrateOrigin = "no") and
+  (if x.hasCanonicalPath() then hasCanonicalPath = "yes" else hasCanonicalPath = "no") and
   getNumberOfAttrs = x.getNumberOfAttrs() and
   (if x.hasExpr() then hasExpr = "yes" else hasExpr = "no") and
   (if x.hasFieldList() then hasFieldList = "yes" else hasFieldList = "no") and
   (if x.hasName() then hasName = "yes" else hasName = "no") and
   if x.hasVisibility() then hasVisibility = "yes" else hasVisibility = "no"
-select x, "hasExtendedCanonicalPath:", hasExtendedCanonicalPath, "hasCrateOrigin:", hasCrateOrigin,
-  "getNumberOfAttrs:", getNumberOfAttrs, "hasExpr:", hasExpr, "hasFieldList:", hasFieldList,
-  "hasName:", hasName, "hasVisibility:", hasVisibility
+select x, "hasCanonicalPath:", hasCanonicalPath, "getNumberOfAttrs:", getNumberOfAttrs, "hasExpr:",
+  hasExpr, "hasFieldList:", hasFieldList, "hasName:", hasName, "hasVisibility:", hasVisibility
diff --git a/rust/ql/test/extractor-tests/generated/Variant/Variant_getCrateOrigin.ql b/rust/ql/test/extractor-tests/generated/Variant/Variant_getCanonicalPath.ql
similarity index 81%
rename from rust/ql/test/extractor-tests/generated/Variant/Variant_getCrateOrigin.ql
rename to rust/ql/test/extractor-tests/generated/Variant/Variant_getCanonicalPath.ql
index 0acfd9827fee..1676fe00652e 100644
--- a/rust/ql/test/extractor-tests/generated/Variant/Variant_getCrateOrigin.ql
+++ b/rust/ql/test/extractor-tests/generated/Variant/Variant_getCanonicalPath.ql
@@ -4,4 +4,4 @@ import TestUtils
 
 from Variant x
 where toBeTested(x) and not x.isUnknown()
-select x, x.getCrateOrigin()
+select x, x.getCanonicalPath()
diff --git a/rust/ql/test/extractor-tests/generated/Variant/Variant_getExtendedCanonicalPath.ql b/rust/ql/test/extractor-tests/generated/Variant/Variant_getExtendedCanonicalPath.ql
deleted file mode 100644
index ad8aaf86a5cf..000000000000
--- a/rust/ql/test/extractor-tests/generated/Variant/Variant_getExtendedCanonicalPath.ql
+++ /dev/null
@@ -1,7 +0,0 @@
-// generated by codegen, do not edit
-import codeql.rust.elements
-import TestUtils
-
-from Variant x
-where toBeTested(x) and not x.isUnknown()
-select x, x.getExtendedCanonicalPath()
diff --git a/rust/ql/test/library-tests/dataflow/local/DataFlowStep.expected b/rust/ql/test/library-tests/dataflow/local/DataFlowStep.expected
index 1ec24c96b486..22a80abdb44e 100644
--- a/rust/ql/test/library-tests/dataflow/local/DataFlowStep.expected
+++ b/rust/ql/test/library-tests/dataflow/local/DataFlowStep.expected
@@ -490,18 +490,6 @@ storeStep
 | main.rs:177:16:177:16 | 2 | Point.x | main.rs:176:16:179:9 | Point {...} |
 | main.rs:178:16:178:25 | source(...) | Point.y | main.rs:176:16:179:9 | Point {...} |
 | main.rs:180:12:180:12 | 4 | Point3D.z | main.rs:175:13:181:5 | Point3D {...} |
-| main.rs:198:27:198:36 | source(...) | Some | main.rs:198:14:198:37 | ...::Some(...) |
-| main.rs:199:27:199:27 | 2 | Some | main.rs:199:14:199:28 | ...::Some(...) |
-| main.rs:211:19:211:28 | source(...) | Some | main.rs:211:14:211:29 | Some(...) |
-| main.rs:212:19:212:19 | 2 | Some | main.rs:212:14:212:20 | Some(...) |
-| main.rs:224:19:224:28 | source(...) | Some | main.rs:224:14:224:29 | Some(...) |
-| main.rs:229:19:229:28 | source(...) | Some | main.rs:229:14:229:29 | Some(...) |
-| main.rs:230:19:230:19 | 2 | Some | main.rs:230:14:230:20 | Some(...) |
-| main.rs:234:10:234:10 | 0 | Some | main.rs:234:5:234:11 | Some(...) |
-| main.rs:238:35:238:44 | source(...) | Ok | main.rs:238:32:238:45 | Ok(...) |
-| main.rs:239:35:239:35 | 2 | Ok | main.rs:239:32:239:36 | Ok(...) |
-| main.rs:240:36:240:45 | source(...) | Err | main.rs:240:32:240:46 | Err(...) |
-| main.rs:247:8:247:8 | 0 | Ok | main.rs:247:5:247:9 | Ok(...) |
 | main.rs:256:29:256:38 | source(...) | A | main.rs:256:14:256:39 | ...::A(...) |
 | main.rs:257:29:257:29 | 2 | B | main.rs:257:14:257:30 | ...::B(...) |
 | main.rs:274:16:274:25 | source(...) | A | main.rs:274:14:274:26 | A(...) |
@@ -530,11 +518,12 @@ storeStep
 | main.rs:373:27:373:27 | 2 | array[] | main.rs:373:23:373:31 | [...] |
 | main.rs:373:30:373:30 | 3 | array[] | main.rs:373:23:373:31 | [...] |
 | main.rs:376:18:376:27 | source(...) | array[] | main.rs:376:5:376:11 | [post] mut_arr |
+<<<<<<< Updated upstream
 | main.rs:406:35:406:61 | default_name | captured default_name | main.rs:406:35:406:61 | \|...\| ... |
 | main.rs:417:27:417:27 | 0 | Some | main.rs:417:22:417:28 | Some(...) |
+=======
+>>>>>>> Stashed changes
 readStep
-| file://:0:0:0:0 | [summary param] self in lang:core::_::<crate::option::Option>::unwrap | Some | file://:0:0:0:0 | [summary] read: Argument[self].Variant[crate::option::Option::Some(0)] in lang:core::_::<crate::option::Option>::unwrap |
-| main.rs:33:9:33:15 | Some(...) | Some | main.rs:33:14:33:14 | _ |
 | main.rs:95:10:95:10 | a | tuple.0 | main.rs:95:10:95:12 | a.0 |
 | main.rs:96:10:96:10 | a | tuple.1 | main.rs:96:10:96:12 | a.1 |
 | main.rs:109:10:109:10 | a | tuple.0 | main.rs:109:10:109:12 | a.0 |
@@ -551,10 +540,6 @@ readStep
 | main.rs:151:9:151:28 | Point {...} | Point.x | main.rs:151:20:151:20 | a |
 | main.rs:151:9:151:28 | Point {...} | Point.y | main.rs:151:26:151:26 | b |
 | main.rs:183:9:186:9 | Point3D {...} | Point3D.plane | main.rs:184:20:184:33 | Point {...} |
-| main.rs:201:9:201:23 | ...::Some(...) | Some | main.rs:201:22:201:22 | n |
-| main.rs:205:9:205:23 | ...::Some(...) | Some | main.rs:205:22:205:22 | n |
-| main.rs:214:9:214:15 | Some(...) | Some | main.rs:214:14:214:14 | n |
-| main.rs:218:9:218:15 | Some(...) | Some | main.rs:218:14:218:14 | n |
 | main.rs:231:14:231:15 | s1 | Ok | main.rs:231:14:231:16 | TryExpr |
 | main.rs:231:14:231:15 | s1 | Some | main.rs:231:14:231:16 | TryExpr |
 | main.rs:233:10:233:11 | s2 | Ok | main.rs:233:10:233:12 | TryExpr |
diff --git a/rust/ql/test/library-tests/dataflow/local/inline-flow.expected b/rust/ql/test/library-tests/dataflow/local/inline-flow.expected
index 185bea1394fb..824e3350f2ae 100644
--- a/rust/ql/test/library-tests/dataflow/local/inline-flow.expected
+++ b/rust/ql/test/library-tests/dataflow/local/inline-flow.expected
@@ -26,6 +26,7 @@ edges
 | main.rs:148:12:148:21 | source(...) | main.rs:147:13:150:5 | Point {...} [Point.x] | provenance |  |
 | main.rs:151:9:151:28 | Point {...} [Point.x] | main.rs:151:20:151:20 | a | provenance |  |
 | main.rs:151:20:151:20 | a | main.rs:152:10:152:10 | a | provenance |  |
+<<<<<<< Updated upstream
 | main.rs:198:14:198:37 | ...::Some(...) [Some] | main.rs:201:9:201:23 | ...::Some(...) [Some] | provenance |  |
 | main.rs:198:27:198:36 | source(...) | main.rs:198:14:198:37 | ...::Some(...) [Some] | provenance |  |
 | main.rs:201:9:201:23 | ...::Some(...) [Some] | main.rs:201:22:201:22 | n | provenance |  |
@@ -45,6 +46,8 @@ edges
 | main.rs:238:35:238:44 | source(...) | main.rs:238:32:238:45 | Ok(...) [Ok] | provenance |  |
 | main.rs:241:14:241:15 | s1 [Ok] | main.rs:241:14:241:16 | TryExpr | provenance |  |
 | main.rs:241:14:241:16 | TryExpr | main.rs:243:10:243:11 | i1 | provenance |  |
+=======
+>>>>>>> Stashed changes
 | main.rs:256:14:256:39 | ...::A(...) [A] | main.rs:259:9:259:25 | ...::A(...) [A] | provenance |  |
 | main.rs:256:14:256:39 | ...::A(...) [A] | main.rs:263:9:263:25 | ...::A(...) [A] | provenance |  |
 | main.rs:256:29:256:38 | source(...) | main.rs:256:14:256:39 | ...::A(...) [A] | provenance |  |
@@ -136,6 +139,7 @@ nodes
 | main.rs:151:9:151:28 | Point {...} [Point.x] | semmle.label | Point {...} [Point.x] |
 | main.rs:151:20:151:20 | a | semmle.label | a |
 | main.rs:152:10:152:10 | a | semmle.label | a |
+<<<<<<< Updated upstream
 | main.rs:198:14:198:37 | ...::Some(...) [Some] | semmle.label | ...::Some(...) [Some] |
 | main.rs:198:27:198:36 | source(...) | semmle.label | source(...) |
 | main.rs:201:9:201:23 | ...::Some(...) [Some] | semmle.label | ...::Some(...) [Some] |
@@ -160,6 +164,8 @@ nodes
 | main.rs:241:14:241:15 | s1 [Ok] | semmle.label | s1 [Ok] |
 | main.rs:241:14:241:16 | TryExpr | semmle.label | TryExpr |
 | main.rs:243:10:243:11 | i1 | semmle.label | i1 |
+=======
+>>>>>>> Stashed changes
 | main.rs:256:14:256:39 | ...::A(...) [A] | semmle.label | ...::A(...) [A] |
 | main.rs:256:29:256:38 | source(...) | semmle.label | source(...) |
 | main.rs:259:9:259:25 | ...::A(...) [A] | semmle.label | ...::A(...) [A] |
@@ -225,6 +231,11 @@ nodes
 | main.rs:379:10:379:19 | mut_arr[0] | semmle.label | mut_arr[0] |
 subpaths
 testFailures
+| main.rs:201:37:201:56 | //... | Missing result: hasValueFlow=13 |
+| main.rs:214:29:214:48 | //... | Missing result: hasValueFlow=14 |
+| main.rs:225:24:225:43 | //... | Missing result: hasValueFlow=19 |
+| main.rs:232:15:232:34 | //... | Missing result: hasValueFlow=20 |
+| main.rs:243:15:243:34 | //... | Missing result: hasValueFlow=20 |
 #select
 | main.rs:15:10:15:18 | source(...) | main.rs:15:10:15:18 | source(...) | main.rs:15:10:15:18 | source(...) | $@ | main.rs:15:10:15:18 | source(...) | source(...) |
 | main.rs:20:10:20:10 | s | main.rs:19:13:19:21 | source(...) | main.rs:20:10:20:10 | s | $@ | main.rs:19:13:19:21 | source(...) | source(...) |
@@ -237,11 +248,14 @@ testFailures
 | main.rs:113:10:113:12 | a.0 | main.rs:111:11:111:20 | source(...) | main.rs:113:10:113:12 | a.0 | $@ | main.rs:111:11:111:20 | source(...) | source(...) |
 | main.rs:121:10:121:15 | ... .1 | main.rs:118:17:118:26 | source(...) | main.rs:121:10:121:15 | ... .1 | $@ | main.rs:118:17:118:26 | source(...) | source(...) |
 | main.rs:152:10:152:10 | a | main.rs:148:12:148:21 | source(...) | main.rs:152:10:152:10 | a | $@ | main.rs:148:12:148:21 | source(...) | source(...) |
+<<<<<<< Updated upstream
 | main.rs:201:33:201:33 | n | main.rs:198:27:198:36 | source(...) | main.rs:201:33:201:33 | n | $@ | main.rs:198:27:198:36 | source(...) | source(...) |
 | main.rs:214:25:214:25 | n | main.rs:211:19:211:28 | source(...) | main.rs:214:25:214:25 | n | $@ | main.rs:211:19:211:28 | source(...) | source(...) |
 | main.rs:225:10:225:20 | s1.unwrap(...) | main.rs:224:19:224:28 | source(...) | main.rs:225:10:225:20 | s1.unwrap(...) | $@ | main.rs:224:19:224:28 | source(...) | source(...) |
 | main.rs:232:10:232:11 | i1 | main.rs:229:19:229:28 | source(...) | main.rs:232:10:232:11 | i1 | $@ | main.rs:229:19:229:28 | source(...) | source(...) |
 | main.rs:243:10:243:11 | i1 | main.rs:238:35:238:44 | source(...) | main.rs:243:10:243:11 | i1 | $@ | main.rs:238:35:238:44 | source(...) | source(...) |
+=======
+>>>>>>> Stashed changes
 | main.rs:259:35:259:35 | n | main.rs:256:29:256:38 | source(...) | main.rs:259:35:259:35 | n | $@ | main.rs:256:29:256:38 | source(...) | source(...) |
 | main.rs:263:55:263:55 | n | main.rs:256:29:256:38 | source(...) | main.rs:263:55:263:55 | n | $@ | main.rs:256:29:256:38 | source(...) | source(...) |
 | main.rs:277:22:277:22 | n | main.rs:274:16:274:25 | source(...) | main.rs:277:22:277:22 | n | $@ | main.rs:274:16:274:25 | source(...) | source(...) |
diff --git a/rust/ql/test/library-tests/dataflow/models/models.expected b/rust/ql/test/library-tests/dataflow/models/models.expected
index 8c5ce17f8c83..b008183cf3f5 100644
--- a/rust/ql/test/library-tests/dataflow/models/models.expected
+++ b/rust/ql/test/library-tests/dataflow/models/models.expected
@@ -10,6 +10,7 @@ models
 | 9 | Summary: repo::test; crate::set_var_field; Argument[0]; ReturnValue.Variant[crate::MyFieldEnum::D::field_d]; value |
 | 10 | Summary: repo::test; crate::set_var_pos; Argument[0]; ReturnValue.Variant[crate::MyPosEnum::B(0)]; value |
 edges
+<<<<<<< Updated upstream
 | main.rs:15:13:15:21 | source(...) | main.rs:16:19:16:19 | s | provenance |  |
 | main.rs:15:13:15:21 | source(...) | main.rs:16:19:16:19 | s | provenance |  |
 | main.rs:16:19:16:19 | s | main.rs:16:10:16:20 | identity(...) | provenance | QL |
@@ -192,10 +193,25 @@ nodes
 | main.rs:175:10:175:10 | t [tuple.1] | semmle.label | t [tuple.1] |
 | main.rs:175:10:175:12 | t.1 | semmle.label | t.1 |
 | main.rs:175:10:175:12 | t.1 | semmle.label | t.1 |
+=======
+nodes
+>>>>>>> Stashed changes
 subpaths
 testFailures
+| main.rs:16:24:16:42 | //... | Missing result: hasValueFlow=1 |
+| main.rs:26:22:26:41 | //... | Missing result: hasTaintFlow=14 |
+| main.rs:42:28:42:46 | //... | Missing result: hasValueFlow=2 |
+| main.rs:57:37:57:55 | //... | Missing result: hasValueFlow=3 |
+| main.rs:74:30:74:48 | //... | Missing result: hasValueFlow=4 |
+| main.rs:89:51:89:69 | //... | Missing result: hasValueFlow=5 |
 invalidSpecComponent
+| lang:core::_::<crate::option::Option>::unwrap | Argument[self].Variant[crate::option::Option::Some(0)] | Variant[crate::option::Option::Some(0)] |
+| repo::test::_::crate::get_var_field | Argument[0].Variant[crate::MyFieldEnum::C::field_c] | Variant[crate::MyFieldEnum::C::field_c] |
+| repo::test::_::crate::get_var_pos | Argument[0].Variant[crate::MyPosEnum::A(0)] | Variant[crate::MyPosEnum::A(0)] |
+| repo::test::_::crate::set_var_field | ReturnValue.Variant[crate::MyFieldEnum::D::field_d] | Variant[crate::MyFieldEnum::D::field_d] |
+| repo::test::_::crate::set_var_pos | ReturnValue.Variant[crate::MyPosEnum::B(0)] | Variant[crate::MyPosEnum::B(0)] |
 #select
+<<<<<<< Updated upstream
 | main.rs:16:10:16:20 | identity(...) | main.rs:15:13:15:21 | source(...) | main.rs:16:10:16:20 | identity(...) | $@ | main.rs:15:13:15:21 | source(...) | source(...) |
 | main.rs:16:10:16:20 | identity(...) | main.rs:15:13:15:21 | source(...) | main.rs:16:10:16:20 | identity(...) | $@ | main.rs:15:13:15:21 | source(...) | source(...) |
 | main.rs:26:10:26:18 | coerce(...) | main.rs:25:13:25:22 | source(...) | main.rs:26:10:26:18 | coerce(...) | $@ | main.rs:25:13:25:22 | source(...) | source(...) |
@@ -217,3 +233,5 @@ invalidSpecComponent
 | main.rs:161:10:161:29 | get_tuple_element(...) | main.rs:159:13:159:22 | source(...) | main.rs:161:10:161:29 | get_tuple_element(...) | $@ | main.rs:159:13:159:22 | source(...) | source(...) |
 | main.rs:175:10:175:12 | t.1 | main.rs:172:13:172:22 | source(...) | main.rs:175:10:175:12 | t.1 | $@ | main.rs:172:13:172:22 | source(...) | source(...) |
 | main.rs:175:10:175:12 | t.1 | main.rs:172:13:172:22 | source(...) | main.rs:175:10:175:12 | t.1 | $@ | main.rs:172:13:172:22 | source(...) | source(...) |
+=======
+>>>>>>> Stashed changes
diff --git a/rust/ql/test/library-tests/dataflow/sources/InlineFlow.ql b/rust/ql/test/library-tests/dataflow/sources/InlineFlow.ql
index 92a41dc46811..6f19d55bb41e 100644
--- a/rust/ql/test/library-tests/dataflow/sources/InlineFlow.ql
+++ b/rust/ql/test/library-tests/dataflow/sources/InlineFlow.ql
@@ -10,7 +10,7 @@ module MyFlowConfig implements DataFlow::ConfigSig {
   predicate isSource(DataFlow::Node source) { source instanceof ThreatModelSource }
 
   predicate isSink(DataFlow::Node sink) {
-    any(CallExpr call | call.getFunction().(PathExpr).getResolvedPath() = "crate::test::sink")
+    any(CallExpr call | call.getFunction().(PathExpr).resolvesToStandardPath("test::test", "sink"))
         .getArgList()
         .getAnArg() = sink.asExpr().getExpr()
   }
diff --git a/rust/ql/test/query-tests/security/CWE-327/BrokenCryptoAlgorithm.expected b/rust/ql/test/query-tests/security/CWE-327/BrokenCryptoAlgorithm.expected
index f1395ff39ec0..8bd6e31abc5c 100644
--- a/rust/ql/test/query-tests/security/CWE-327/BrokenCryptoAlgorithm.expected
+++ b/rust/ql/test/query-tests/security/CWE-327/BrokenCryptoAlgorithm.expected
@@ -1,21 +1,23 @@
-| test_cipher.rs:20:27:20:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:20:27:20:48 | ...::new(...) | The cryptographic algorithm RC4 |
-| test_cipher.rs:23:27:23:60 | ...::new_from_slice(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:23:27:23:60 | ...::new_from_slice(...) | The cryptographic algorithm RC4 |
-| test_cipher.rs:26:27:26:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:26:27:26:48 | ...::new(...) | The cryptographic algorithm RC4 |
-| test_cipher.rs:29:27:29:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:29:27:29:48 | ...::new(...) | The cryptographic algorithm RC4 |
+#select
 | test_cipher.rs:59:23:59:42 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:59:23:59:42 | ...::new(...) | The cryptographic algorithm DES |
 | test_cipher.rs:63:23:63:47 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:63:23:63:47 | ...::new(...) | The cryptographic algorithm DES |
-| test_cipher.rs:67:23:67:46 | ...::new_from_slice(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:67:23:67:46 | ...::new_from_slice(...) | The cryptographic algorithm DES |
 | test_cipher.rs:71:23:71:42 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:71:23:71:42 | ...::new(...) | The cryptographic algorithm DES |
 | test_cipher.rs:75:27:75:46 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:75:27:75:46 | ...::new(...) | The cryptographic algorithm DES |
 | test_cipher.rs:80:24:80:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:80:24:80:48 | ...::new(...) | The cryptographic algorithm 3DES |
 | test_cipher.rs:84:24:84:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:84:24:84:48 | ...::new(...) | The cryptographic algorithm 3DES |
 | test_cipher.rs:88:24:88:48 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:88:24:88:48 | ...::new(...) | The cryptographic algorithm 3DES |
-| test_cipher.rs:92:24:92:52 | ...::new_from_slice(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:92:24:92:52 | ...::new_from_slice(...) | The cryptographic algorithm 3DES |
 | test_cipher.rs:97:23:97:42 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:97:23:97:42 | ...::new(...) | The cryptographic algorithm RC2 |
 | test_cipher.rs:101:23:101:46 | ...::new_from_slice(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:101:23:101:46 | ...::new_from_slice(...) | The cryptographic algorithm RC2 |
-| test_cipher.rs:105:23:105:56 | ...::new_with_eff_key_len(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:105:23:105:56 | ...::new_with_eff_key_len(...) | The cryptographic algorithm RC2 |
-| test_cipher.rs:110:23:110:50 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:110:23:110:50 | ...::new(...) | The cryptographic algorithm RC5 |
-| test_cipher.rs:114:23:114:55 | ...::new_from_slice(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:114:23:114:55 | ...::new_from_slice(...) | The cryptographic algorithm RC5 |
-| test_cipher.rs:132:23:132:76 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:132:23:132:76 | ...::new(...) | The cryptographic algorithm DES |
-| test_cipher.rs:138:23:138:76 | ...::new_from_slices(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:138:23:138:76 | ...::new_from_slices(...) | The cryptographic algorithm DES |
-| test_cipher.rs:141:23:141:76 | ...::new(...) | $@ is broken or weak, and should not be used. | test_cipher.rs:141:23:141:76 | ...::new(...) | The cryptographic algorithm DES |
+testFailures
+| test_cipher.rs:20:51:20:95 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:23:72:23:116 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:26:51:26:95 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:29:51:29:95 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:67:64:67:108 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:92:64:92:108 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:105:59:105:103 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:110:53:110:97 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:114:67:114:111 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:132:79:132:123 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:138:88:138:132 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
+| test_cipher.rs:141:79:141:123 | //... | Missing result: Alert[rust/weak-cryptographic-algorithm] |
diff --git a/rust/schema/prelude.py b/rust/schema/prelude.py
index ec67d7357ab4..ab37500a12a2 100644
--- a/rust/schema/prelude.py
+++ b/rust/schema/prelude.py
@@ -80,21 +80,13 @@ class Addressable(AstNode):
 
     TODO: This does not yet include all possible cases.
     """
-    extended_canonical_path: optional[string] | desc("""
-        Either a canonical path (see https://doc.rust-lang.org/reference/paths.html#canonical-paths),
-        or `{<block id>}::name` for addressable items defined in an anonymous block (and only
-        addressable there-in).
-    """) | rust.detach | ql.internal
-    crate_origin: optional[string] | desc("One of `rustc:<name>`, `repo:<repository>:<name>` or `lang:<name>`.") | rust.detach | ql.internal
-
+    canonical_path: optional["CanonicalPath"] | rust.detach | ql.internal
 
 class Resolvable(AstNode):
     """
     One of `PathExpr`, `RecordExpr`, `PathPat`, `RecordPat`, `TupleStructPat` or `MethodCallExpr`.
     """
-    resolved_path: optional[string] | rust.detach | ql.internal
-    resolved_crate_origin: optional[string] | rust.detach | ql.internal
-
+    resolved_canonical_path: optional["CanonicalPath"] | rust.detach | ql.internal
 
 class PathAstNode(Resolvable):
     """
@@ -109,3 +101,131 @@ class ExtractorStep(Element):
     action: string
     file: File
     duration_ms: int
+
+@group("canonical_paths")
+@qltest.collapse_hierarchy
+@qltest.skip
+class CanonicalPathElement(Element):
+    """
+    The base class for all elements in a canonical path.
+    """
+
+class CanonicalPath(CanonicalPathElement):
+    """
+    The base class for all canonical paths that can be the result of a path resolution.
+    """
+
+class Namespace(CanonicalPath):
+    """
+    A namespace, comprised of a crate root and a possibly empty `::` separated module path.
+    """
+    root: "CrateRef" | child
+    path: string
+
+class CrateRef(CanonicalPathElement):
+    """
+    The base class for all crate references.
+    """
+
+class LangCrateRef(CrateRef):
+    """
+    A reference to a crate in the Rust standard libraries.
+    """
+    name: string
+
+class RustcCrateRef(CrateRef):
+    """
+    A reference to a crate provided by rustc. TODO: understand where these come from.
+    """
+    name: string
+
+class RepoCrateRef(CrateRef):
+    """
+    A reference to a crate in the repository.
+    """
+    # TODO this should be unified with crate identification done to extract dependency definitions
+    name: optional[string]
+    repo: optional[string]
+    source: File
+
+class TypeGenericArg(CanonicalPathElement):
+    """
+    A generic argument for a type.
+    """
+
+class TypeGenericTypeArg(TypeGenericArg):
+    """
+    A generic argument for a type that is a type.
+    """
+    path: "TypeCanonicalPath" | child
+
+
+class ConstGenericTypeArg(TypeGenericArg):
+    """
+    A generic argument for a type that is a const.
+    """
+    value: string
+
+
+class TypeCanonicalPath(CanonicalPath):
+    """
+    The base for canonical paths for types.
+    """
+    pass
+
+class ConcreteTypeCanonicalPath(TypeCanonicalPath):
+    """
+    A canonical path for an actual type.
+    """
+    path: "ParametrizedCanonicalPath" | child
+
+class PlaceholderTypeCanonicalPath(TypeCanonicalPath):
+    """
+    A placeholder for a type parameter bound in an impl.
+    """
+
+class BuiltinTypeCanonicalPath(TypeCanonicalPath):
+    """
+    A canonical path for a builtin type.
+    """
+    name: string
+
+class DerivedTypeCanonicalPath(TypeCanonicalPath):
+    """
+    A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
+    """
+    modifiers: list[string]
+    base: list[TypeCanonicalPath] | child
+
+class ModuleItemCanonicalPath(CanonicalPath):
+    """
+    A canonical path for an item defined in a module.
+    """
+    namespace: Namespace | child
+    name: string
+
+class ParametrizedCanonicalPath(CanonicalPath):
+    base: ModuleItemCanonicalPath | child
+    generic_args: list[TypeGenericArg] | child
+
+class TypeItemCanonicalPath(CanonicalPath):
+    """
+    A canonical path for an item defined in a type or trait.
+    """
+    parent: ModuleItemCanonicalPath | child
+    name: string
+
+class TraitImplItemCanonicalPath(CanonicalPath):
+    """
+    A canonical path for an item defined in a trait impl.
+    """
+    type_path: TypeCanonicalPath | child
+    trait_path: ParametrizedCanonicalPath | child
+    name: string
+
+class TypeImplItemCanonicalPath(CanonicalPath):
+    """
+    A canonical path for an item defined in a type impl.
+    """
+    parent: ModuleItemCanonicalPath | child
+    name: string