From 4110636032f0fba089ed8779e7c2085e2e5b10ca Mon Sep 17 00:00:00 2001
From: Paolo Tranquilli <redsun82@gihub.com>
Date: Thu, 20 Mar 2025 12:03:26 +0100
Subject: [PATCH] Rust: preserve ordering in rust generated code

This is a small devex improvement to the rust code generator.

Usage of `sorted` in `rustgen.py` was causing the generated code to be
completely reshuffled on renames, which made diffs hard to follow. As an
example see [this generated file diff](https://github.com/github/codeql/pull/19059/files#diff-c938ba77a3398dd4c633ada5702a03477705c24740a2f7d1e40d4b270d8c3f86).

This will make the order deterministically based on the order of
definitions in the schema file. This means that renames will find the
same place in the generated file, and the place in the generated file
will generally be more predictable with respect to the schema.

However, that does mean this change is heavily reshuffling the generated
code.
---
 misc/codegen/generators/rustgen.py           |    4 +-
 rust/extractor/src/generated/.generated.list |    2 +-
 rust/extractor/src/generated/top.rs          | 3534 +++++++++---------
 3 files changed, 1771 insertions(+), 1769 deletions(-)

diff --git a/misc/codegen/generators/rustgen.py b/misc/codegen/generators/rustgen.py
index b47e5cc4bd9..38d2ae55d44 100644
--- a/misc/codegen/generators/rustgen.py
+++ b/misc/codegen/generators/rustgen.py
@@ -96,7 +96,9 @@ class Processor:
             name=name,
             fields=fields,
             detached_fields=detached_fields,
-            ancestors=sorted(set(a.name for a in _get_ancestors(cls, self._classmap))),
+            # remove duplicates but preserve ordering
+            # (`dict` preserves insertion order while `set` doesn't)
+            ancestors=[*{a.name: None for a in _get_ancestors(cls, self._classmap)}],
             entry_table=inflection.tableize(cls.name) if not cls.derived else None,
         )
 
diff --git a/rust/extractor/src/generated/.generated.list b/rust/extractor/src/generated/.generated.list
index 7a3155e7afa..c80e596b7a8 100644
--- a/rust/extractor/src/generated/.generated.list
+++ b/rust/extractor/src/generated/.generated.list
@@ -1,2 +1,2 @@
 mod.rs 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7
-top.rs b290c599a2696c64c3391003de990c7036ac1990f43b507723d10519d18fcbee b290c599a2696c64c3391003de990c7036ac1990f43b507723d10519d18fcbee
+top.rs 765a45234eacc510b2eeef9c44852766c3a818902108a2e921327804032bbc5a 765a45234eacc510b2eeef9c44852766c3a818902108a2e921327804032bbc5a
diff --git a/rust/extractor/src/generated/top.rs b/rust/extractor/src/generated/top.rs
index 7755ad50bc2..b797f7952fa 100644
--- a/rust/extractor/src/generated/top.rs
+++ b/rust/extractor/src/generated/top.rs
@@ -101,18 +101,18 @@ impl trap::TrapClass for AstNode {
     fn class_name() -> &'static str { "AstNode" }
 }
 
-impl From<trap::Label<AstNode>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AstNode>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme AstNode is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -158,18 +158,18 @@ impl trap::TrapClass for Crate {
     fn class_name() -> &'static str { "Crate" }
 }
 
-impl From<trap::Label<Crate>> for trap::Label<Element> {
+impl From<trap::Label<Crate>> for trap::Label<Locatable> {
     fn from(value: trap::Label<Crate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Crate is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Crate is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Crate>> for trap::Label<Locatable> {
+impl From<trap::Label<Crate>> for trap::Label<Element> {
     fn from(value: trap::Label<Crate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Crate is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme Crate is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -195,18 +195,18 @@ impl trap::TrapClass for Missing {
     fn class_name() -> &'static str { "Missing" }
 }
 
-impl From<trap::Label<Missing>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Unextracted
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Missing>> for trap::Label<Unextracted> {
+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 Unextracted
+        // SAFETY: this is safe because in the dbscheme Missing is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -232,18 +232,18 @@ impl trap::TrapClass for Unimplemented {
     fn class_name() -> &'static str { "Unimplemented" }
 }
 
-impl From<trap::Label<Unimplemented>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Unextracted
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Unimplemented>> for trap::Label<Unextracted> {
+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 Unextracted
+        // SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -282,18 +282,18 @@ impl From<trap::Label<Abi>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Abi>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Abi>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Abi is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -327,18 +327,18 @@ impl From<trap::Label<Addressable>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Addressable>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Addressable>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Addressable is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -377,18 +377,18 @@ impl From<trap::Label<ArgList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ArgList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ArgList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ArgList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -423,18 +423,18 @@ impl From<trap::Label<AsmDirSpec>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmDirSpec>> for trap::Label<Element> {
+impl From<trap::Label<AsmDirSpec>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmDirSpec>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmDirSpec is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmDirSpec is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmDirSpec>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmDirSpec>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmDirSpec>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmDirSpec is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmDirSpec is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -459,18 +459,18 @@ impl From<trap::Label<AsmOperand>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmOperand>> for trap::Label<Element> {
+impl From<trap::Label<AsmOperand>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmOperand>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperand is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmOperand is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmOperand>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmOperand>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmOperand>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperand is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmOperand is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -513,18 +513,18 @@ impl From<trap::Label<AsmOperandExpr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmOperandExpr>> for trap::Label<Element> {
+impl From<trap::Label<AsmOperandExpr>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmOperandExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperandExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmOperandExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmOperandExpr>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmOperandExpr>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmOperandExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperandExpr is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmOperandExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -563,18 +563,18 @@ impl From<trap::Label<AsmOption>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmOption>> for trap::Label<Element> {
+impl From<trap::Label<AsmOption>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmOption>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOption is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmOption is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmOption>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmOption>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmOption>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOption is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmOption is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -599,18 +599,18 @@ impl From<trap::Label<AsmPiece>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmPiece>> for trap::Label<Element> {
+impl From<trap::Label<AsmPiece>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmPiece>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmPiece is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmPiece is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmPiece>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmPiece>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmPiece>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmPiece is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmPiece is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -649,18 +649,18 @@ impl From<trap::Label<AsmRegSpec>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmRegSpec>> for trap::Label<Element> {
+impl From<trap::Label<AsmRegSpec>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmRegSpec>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmRegSpec is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmRegSpec is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmRegSpec>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmRegSpec>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmRegSpec>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmRegSpec is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmRegSpec is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -685,18 +685,18 @@ impl From<trap::Label<AssocItem>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AssocItem>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AssocItem>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -739,18 +739,18 @@ impl From<trap::Label<AssocItemList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AssocItemList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AssocItemList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -789,18 +789,18 @@ impl From<trap::Label<Attr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Attr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Attr>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Attr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -825,18 +825,18 @@ impl From<trap::Label<Callable>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Callable>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Callable>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Callable is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -875,18 +875,18 @@ impl From<trap::Label<ClosureBinder>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ClosureBinder>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ClosureBinder>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -911,18 +911,18 @@ impl From<trap::Label<Expr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Expr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Expr>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Expr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -947,18 +947,18 @@ impl From<trap::Label<ExternItem>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ExternItem>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternItem>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1001,18 +1001,18 @@ impl From<trap::Label<ExternItemList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ExternItemList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternItemList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1037,18 +1037,18 @@ impl From<trap::Label<FieldList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<FieldList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<FieldList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme FieldList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1091,18 +1091,18 @@ impl From<trap::Label<FormatArgsArg>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<FormatArgsArg>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<FormatArgsArg>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1127,18 +1127,18 @@ impl From<trap::Label<GenericArg>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<GenericArg>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<GenericArg>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1177,18 +1177,18 @@ impl From<trap::Label<GenericArgList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<GenericArgList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<GenericArgList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1213,18 +1213,18 @@ impl From<trap::Label<GenericParam>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<GenericParam>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<GenericParam>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1263,18 +1263,18 @@ impl From<trap::Label<GenericParamList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<GenericParamList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<GenericParamList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1317,18 +1317,18 @@ impl From<trap::Label<ItemList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ItemList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ItemList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ItemList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1367,18 +1367,18 @@ impl From<trap::Label<Label>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Label>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Label is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Label>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Label is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1417,18 +1417,18 @@ impl From<trap::Label<LetElse>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<LetElse>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LetElse>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme LetElse is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1467,18 +1467,18 @@ impl From<trap::Label<MacroItems>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<MacroItems>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroItems>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MacroItems is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1521,18 +1521,18 @@ impl From<trap::Label<MacroStmts>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<MacroStmts>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroStmts>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MacroStmts is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1583,18 +1583,18 @@ impl From<trap::Label<MatchArm>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<MatchArm>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MatchArm>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MatchArm is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1637,18 +1637,18 @@ impl From<trap::Label<MatchArmList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<MatchArmList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MatchArmList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MatchArmList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1687,18 +1687,18 @@ impl From<trap::Label<MatchGuard>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<MatchGuard>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MatchGuard>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MatchGuard is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1749,18 +1749,18 @@ impl From<trap::Label<Meta>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Meta>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Meta>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Meta is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1799,18 +1799,18 @@ impl From<trap::Label<Name>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Name>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Name is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Name>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Name is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1835,18 +1835,18 @@ impl From<trap::Label<ParamBase>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ParamBase>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParamBase>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ParamBase is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1889,18 +1889,18 @@ impl From<trap::Label<ParamList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ParamList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParamList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ParamList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1939,18 +1939,18 @@ impl From<trap::Label<ParenthesizedArgList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ParenthesizedArgList>> for trap::Label<Element> {
+impl From<trap::Label<ParenthesizedArgList>> for trap::Label<Locatable> {
     fn from(value: trap::Label<ParenthesizedArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenthesizedArgList is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme ParenthesizedArgList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParenthesizedArgList>> for trap::Label<Locatable> {
+impl From<trap::Label<ParenthesizedArgList>> for trap::Label<Element> {
     fn from(value: trap::Label<ParenthesizedArgList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ParenthesizedArgList is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme ParenthesizedArgList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -1975,18 +1975,18 @@ impl From<trap::Label<Pat>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Pat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Pat>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Pat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2029,18 +2029,18 @@ impl From<trap::Label<Path>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Path>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Path is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Path>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Path is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2104,18 +2104,18 @@ impl From<trap::Label<PathSegment>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<PathSegment>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathSegment>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme PathSegment is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2154,18 +2154,18 @@ impl From<trap::Label<Rename>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Rename>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Rename>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Rename is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2199,18 +2199,18 @@ impl From<trap::Label<Resolvable>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Resolvable>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Resolvable>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Resolvable is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2249,18 +2249,18 @@ impl From<trap::Label<RetTypeRepr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<RetTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RetTypeRepr>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme RetTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2295,18 +2295,18 @@ impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ReturnTypeSyntax>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ReturnTypeSyntax is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2349,18 +2349,18 @@ impl From<trap::Label<SourceFile>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<SourceFile>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<SourceFile>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme SourceFile is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2385,18 +2385,18 @@ impl From<trap::Label<Stmt>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Stmt>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Stmt>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Stmt is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2443,18 +2443,18 @@ impl From<trap::Label<StmtList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StmtList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StmtList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme StmtList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2501,18 +2501,18 @@ impl From<trap::Label<StructExprField>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StructExprField>> for trap::Label<Element> {
+impl From<trap::Label<StructExprField>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructExprField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExprField is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructExprField is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructExprField>> for trap::Label<Locatable> {
+impl From<trap::Label<StructExprField>> for trap::Label<Element> {
     fn from(value: trap::Label<StructExprField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExprField is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme StructExprField is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2559,18 +2559,18 @@ impl From<trap::Label<StructExprFieldList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StructExprFieldList>> for trap::Label<Element> {
+impl From<trap::Label<StructExprFieldList>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructExprFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExprFieldList is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructExprFieldList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructExprFieldList>> for trap::Label<Locatable> {
+impl From<trap::Label<StructExprFieldList>> for trap::Label<Element> {
     fn from(value: trap::Label<StructExprFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExprFieldList is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme StructExprFieldList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2625,18 +2625,18 @@ impl From<trap::Label<StructField>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StructField>> for trap::Label<Element> {
+impl From<trap::Label<StructField>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructField is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructField is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructField>> for trap::Label<Locatable> {
+impl From<trap::Label<StructField>> for trap::Label<Element> {
     fn from(value: trap::Label<StructField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructField is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme StructField is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2683,18 +2683,18 @@ impl From<trap::Label<StructPatField>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StructPatField>> for trap::Label<Element> {
+impl From<trap::Label<StructPatField>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructPatField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPatField is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructPatField is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructPatField>> for trap::Label<Locatable> {
+impl From<trap::Label<StructPatField>> for trap::Label<Element> {
     fn from(value: trap::Label<StructPatField>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPatField is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme StructPatField is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2737,18 +2737,18 @@ impl From<trap::Label<StructPatFieldList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<StructPatFieldList>> for trap::Label<Element> {
+impl From<trap::Label<StructPatFieldList>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructPatFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPatFieldList is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructPatFieldList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructPatFieldList>> for trap::Label<Locatable> {
+impl From<trap::Label<StructPatFieldList>> for trap::Label<Element> {
     fn from(value: trap::Label<StructPatFieldList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPatFieldList is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme StructPatFieldList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2773,18 +2773,18 @@ impl From<trap::Label<Token>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Token>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Token is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Token>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Token is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2819,18 +2819,18 @@ impl From<trap::Label<TokenTree>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<TokenTree>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TokenTree>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TokenTree is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2877,18 +2877,18 @@ impl From<trap::Label<TupleField>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<TupleField>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TupleField>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TupleField is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2943,18 +2943,18 @@ impl From<trap::Label<TypeBound>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<TypeBound>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeBound>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeBound is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -2993,18 +2993,18 @@ impl From<trap::Label<TypeBoundList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<TypeBoundList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeBoundList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeBoundList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3029,18 +3029,18 @@ impl From<trap::Label<TypeRepr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<TypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeRepr>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3065,18 +3065,18 @@ impl From<trap::Label<UseBoundGenericArg>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<UseBoundGenericArg>> for trap::Label<Element> {
+impl From<trap::Label<UseBoundGenericArg>> for trap::Label<Locatable> {
     fn from(value: trap::Label<UseBoundGenericArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseBoundGenericArg is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme UseBoundGenericArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<UseBoundGenericArg>> for trap::Label<Locatable> {
+impl From<trap::Label<UseBoundGenericArg>> for trap::Label<Element> {
     fn from(value: trap::Label<UseBoundGenericArg>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseBoundGenericArg is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme UseBoundGenericArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3115,18 +3115,18 @@ impl From<trap::Label<UseBoundGenericArgs>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<UseBoundGenericArgs>> for trap::Label<Element> {
+impl From<trap::Label<UseBoundGenericArgs>> for trap::Label<Locatable> {
     fn from(value: trap::Label<UseBoundGenericArgs>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseBoundGenericArgs is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme UseBoundGenericArgs is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<UseBoundGenericArgs>> for trap::Label<Locatable> {
+impl From<trap::Label<UseBoundGenericArgs>> for trap::Label<Element> {
     fn from(value: trap::Label<UseBoundGenericArgs>) -> Self {
-        // SAFETY: this is safe because in the dbscheme UseBoundGenericArgs is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme UseBoundGenericArgs is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3177,18 +3177,18 @@ impl From<trap::Label<UseTree>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<UseTree>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<UseTree>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme UseTree is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3227,18 +3227,18 @@ impl From<trap::Label<UseTreeList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<UseTreeList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<UseTreeList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme UseTreeList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3277,18 +3277,18 @@ impl From<trap::Label<VariantList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<VariantList>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<VariantList>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme VariantList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3327,18 +3327,18 @@ impl From<trap::Label<Visibility>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Visibility>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Visibility>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Visibility is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3377,18 +3377,18 @@ impl From<trap::Label<WhereClause>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<WhereClause>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<WhereClause>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme WhereClause is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3439,18 +3439,18 @@ impl From<trap::Label<WherePred>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<WherePred>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<WherePred>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme WherePred is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3488,24 +3488,6 @@ 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
@@ -3515,6 +3497,15 @@ impl From<trap::Label<ArrayExprInternal>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ArrayExprInternal>) -> Self {
         // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Locatable
@@ -3524,6 +3515,15 @@ impl From<trap::Label<ArrayExprInternal>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ArrayTypeRepr {
     pub id: trap::TrapId<ArrayTypeRepr>,
@@ -3551,18 +3551,18 @@ impl trap::TrapClass for ArrayTypeRepr {
     fn class_name() -> &'static str { "ArrayTypeRepr" }
 }
 
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3578,9 +3578,9 @@ impl From<trap::Label<ArrayTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ArrayTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme ArrayTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3624,18 +3624,18 @@ impl From<trap::Label<AsmClobberAbi>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmClobberAbi>> for trap::Label<Element> {
+impl From<trap::Label<AsmClobberAbi>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmClobberAbi>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmClobberAbi is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmClobberAbi is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmClobberAbi>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmClobberAbi>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmClobberAbi>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmClobberAbi is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmClobberAbi is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3687,18 +3687,18 @@ impl From<trap::Label<AsmConst>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmConst>> for trap::Label<Element> {
+impl From<trap::Label<AsmConst>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmConst>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmConst is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmConst is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmConst>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmConst>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmConst>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmConst is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmConst is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3736,24 +3736,6 @@ 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
@@ -3763,6 +3745,15 @@ impl From<trap::Label<AsmExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<AsmExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Locatable
@@ -3772,6 +3763,15 @@ impl From<trap::Label<AsmExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct AsmLabel {
     pub id: trap::TrapId<AsmLabel>,
@@ -3813,18 +3813,18 @@ impl From<trap::Label<AsmLabel>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmLabel>> for trap::Label<Element> {
+impl From<trap::Label<AsmLabel>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmLabel>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmLabel is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmLabel is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmLabel>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmLabel>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmLabel>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmLabel is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmLabel is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3876,18 +3876,18 @@ impl From<trap::Label<AsmOperandNamed>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmOperandNamed>> for trap::Label<Element> {
+impl From<trap::Label<AsmOperandNamed>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmOperandNamed>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperandNamed is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmOperandNamed is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmOperandNamed>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmOperandNamed>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmOperandNamed>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOperandNamed is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmOperandNamed is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3935,18 +3935,18 @@ impl From<trap::Label<AsmOptionsList>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmOptionsList>> for trap::Label<Element> {
+impl From<trap::Label<AsmOptionsList>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmOptionsList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOptionsList is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmOptionsList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmOptionsList>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmOptionsList>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmOptionsList>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmOptionsList is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmOptionsList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4002,18 +4002,18 @@ impl From<trap::Label<AsmRegOperand>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmRegOperand>> for trap::Label<Element> {
+impl From<trap::Label<AsmRegOperand>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmRegOperand>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmRegOperand is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmRegOperand is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmRegOperand>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmRegOperand>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmRegOperand>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmRegOperand is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmRegOperand is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4061,18 +4061,18 @@ impl From<trap::Label<AsmSym>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<AsmSym>> for trap::Label<Element> {
+impl From<trap::Label<AsmSym>> for trap::Label<Locatable> {
     fn from(value: trap::Label<AsmSym>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmSym is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme AsmSym is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmSym>> for trap::Label<Locatable> {
+impl From<trap::Label<AsmSym>> for trap::Label<Element> {
     fn from(value: trap::Label<AsmSym>) -> Self {
-        // SAFETY: this is safe because in the dbscheme AsmSym is a subclass of Locatable
+        // SAFETY: this is safe because in the dbscheme AsmSym is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4130,24 +4130,6 @@ 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
@@ -4157,6 +4139,15 @@ impl From<trap::Label<AssocTypeArg>> for trap::Label<GenericArg> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<AssocTypeArg>) -> Self {
         // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Locatable
@@ -4166,6 +4157,15 @@ impl From<trap::Label<AssocTypeArg>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct AwaitExpr {
     pub id: trap::TrapId<AwaitExpr>,
@@ -4193,24 +4193,6 @@ 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
@@ -4220,6 +4202,15 @@ impl From<trap::Label<AwaitExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<AwaitExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Locatable
@@ -4229,6 +4220,15 @@ impl From<trap::Label<AwaitExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct BecomeExpr {
     pub id: trap::TrapId<BecomeExpr>,
@@ -4256,24 +4256,6 @@ 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
@@ -4283,6 +4265,15 @@ impl From<trap::Label<BecomeExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<BecomeExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Locatable
@@ -4292,6 +4283,15 @@ impl From<trap::Label<BecomeExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct BinaryExpr {
     pub id: trap::TrapId<BinaryExpr>,
@@ -4327,24 +4327,6 @@ 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
@@ -4354,6 +4336,15 @@ impl From<trap::Label<BinaryExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<BinaryExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Locatable
@@ -4363,6 +4354,15 @@ impl From<trap::Label<BinaryExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct BoxPat {
     pub id: trap::TrapId<BoxPat>,
@@ -4386,18 +4386,18 @@ impl trap::TrapClass for BoxPat {
     fn class_name() -> &'static str { "BoxPat" }
 }
 
-impl From<trap::Label<BoxPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BoxPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4413,9 +4413,9 @@ impl From<trap::Label<BoxPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<BoxPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme BoxPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4453,24 +4453,6 @@ 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
@@ -4480,6 +4462,15 @@ impl From<trap::Label<BreakExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<BreakExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Locatable
@@ -4489,6 +4480,15 @@ impl From<trap::Label<BreakExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct CallExprBase {
     _unused: ()
@@ -4498,24 +4498,6 @@ 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
@@ -4525,6 +4507,15 @@ impl From<trap::Label<CallExprBase>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<CallExprBase>) -> Self {
         // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Locatable
@@ -4534,6 +4525,15 @@ impl From<trap::Label<CallExprBase>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct CastExpr {
     pub id: trap::TrapId<CastExpr>,
@@ -4565,24 +4565,6 @@ 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
@@ -4592,6 +4574,15 @@ impl From<trap::Label<CastExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<CastExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Locatable
@@ -4601,6 +4592,15 @@ impl From<trap::Label<CastExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ClosureExpr {
     pub id: trap::TrapId<ClosureExpr>,
@@ -4660,6 +4660,15 @@ impl trap::TrapClass for ClosureExpr {
     fn class_name() -> &'static str { "ClosureExpr" }
 }
 
+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<AstNode> {
     fn from(value: trap::Label<ClosureExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of AstNode
@@ -4669,9 +4678,9 @@ impl From<trap::Label<ClosureExpr>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<Callable> {
+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 Callable
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4687,18 +4696,9 @@ impl From<trap::Label<ClosureExpr>> for trap::Label<Element> {
     }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<Expr> {
+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 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
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Callable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4726,18 +4726,18 @@ impl trap::TrapClass for Comment {
     fn class_name() -> &'static str { "Comment" }
 }
 
-impl From<trap::Label<Comment>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Token
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Comment>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4753,9 +4753,9 @@ impl From<trap::Label<Comment>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Comment>> for trap::Label<Token> {
+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 Token
+        // SAFETY: this is safe because in the dbscheme Comment is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4785,24 +4785,6 @@ 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
@@ -4812,6 +4794,15 @@ impl From<trap::Label<ConstArg>> for trap::Label<GenericArg> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ConstArg>) -> Self {
         // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Locatable
@@ -4821,6 +4812,15 @@ impl From<trap::Label<ConstArg>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ConstBlockPat {
     pub id: trap::TrapId<ConstBlockPat>,
@@ -4848,18 +4848,18 @@ impl trap::TrapClass for ConstBlockPat {
     fn class_name() -> &'static str { "ConstBlockPat" }
 }
 
-impl From<trap::Label<ConstBlockPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ConstBlockPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4875,9 +4875,9 @@ impl From<trap::Label<ConstBlockPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ConstBlockPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme ConstBlockPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4923,24 +4923,6 @@ 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
@@ -4950,6 +4932,15 @@ impl From<trap::Label<ConstParam>> for trap::Label<GenericParam> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ConstParam>) -> Self {
         // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Locatable
@@ -4959,6 +4950,15 @@ impl From<trap::Label<ConstParam>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ContinueExpr {
     pub id: trap::TrapId<ContinueExpr>,
@@ -4986,24 +4986,6 @@ 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
@@ -5013,6 +4995,15 @@ impl From<trap::Label<ContinueExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ContinueExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Locatable
@@ -5022,6 +5013,15 @@ impl From<trap::Label<ContinueExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct DynTraitTypeRepr {
     pub id: trap::TrapId<DynTraitTypeRepr>,
@@ -5045,18 +5045,18 @@ impl trap::TrapClass for DynTraitTypeRepr {
     fn class_name() -> &'static str { "DynTraitTypeRepr" }
 }
 
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5072,9 +5072,9 @@ impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<DynTraitTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme DynTraitTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5104,18 +5104,18 @@ impl trap::TrapClass for ExprStmt {
     fn class_name() -> &'static str { "ExprStmt" }
 }
 
-impl From<trap::Label<ExprStmt>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExprStmt>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5131,9 +5131,9 @@ impl From<trap::Label<ExprStmt>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ExprStmt>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme ExprStmt is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5171,24 +5171,6 @@ 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
@@ -5198,6 +5180,15 @@ impl From<trap::Label<FieldExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<FieldExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Locatable
@@ -5207,6 +5198,15 @@ impl From<trap::Label<FieldExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct FnPtrTypeRepr {
     pub id: trap::TrapId<FnPtrTypeRepr>,
@@ -5250,18 +5250,18 @@ impl trap::TrapClass for FnPtrTypeRepr {
     fn class_name() -> &'static str { "FnPtrTypeRepr" }
 }
 
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5277,9 +5277,9 @@ impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<FnPtrTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme FnPtrTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5313,18 +5313,18 @@ impl trap::TrapClass for ForTypeRepr {
     fn class_name() -> &'static str { "ForTypeRepr" }
 }
 
-impl From<trap::Label<ForTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ForTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5340,9 +5340,9 @@ impl From<trap::Label<ForTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ForTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme ForTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5380,24 +5380,6 @@ 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
@@ -5407,6 +5389,15 @@ impl From<trap::Label<FormatArgsExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<FormatArgsExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Locatable
@@ -5416,6 +5407,15 @@ impl From<trap::Label<FormatArgsExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct IdentPat {
     pub id: trap::TrapId<IdentPat>,
@@ -5455,18 +5455,18 @@ impl trap::TrapClass for IdentPat {
     fn class_name() -> &'static str { "IdentPat" }
 }
 
-impl From<trap::Label<IdentPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<IdentPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5482,9 +5482,9 @@ impl From<trap::Label<IdentPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<IdentPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme IdentPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5526,24 +5526,6 @@ 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
@@ -5553,6 +5535,15 @@ impl From<trap::Label<IfExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<IfExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Locatable
@@ -5562,6 +5553,15 @@ impl From<trap::Label<IfExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ImplTraitTypeRepr {
     pub id: trap::TrapId<ImplTraitTypeRepr>,
@@ -5585,18 +5585,18 @@ impl trap::TrapClass for ImplTraitTypeRepr {
     fn class_name() -> &'static str { "ImplTraitTypeRepr" }
 }
 
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5612,9 +5612,9 @@ impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ImplTraitTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme ImplTraitTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5652,24 +5652,6 @@ 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
@@ -5679,6 +5661,15 @@ impl From<trap::Label<IndexExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<IndexExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Locatable
@@ -5688,6 +5679,15 @@ impl From<trap::Label<IndexExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct InferTypeRepr {
     pub id: trap::TrapId<InferTypeRepr>,
@@ -5707,18 +5707,18 @@ impl trap::TrapClass for InferTypeRepr {
     fn class_name() -> &'static str { "InferTypeRepr" }
 }
 
-impl From<trap::Label<InferTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<InferTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5734,9 +5734,9 @@ impl From<trap::Label<InferTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<InferTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme InferTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5752,9 +5752,9 @@ impl trap::TrapClass for Item {
     fn class_name() -> &'static str { "Item" }
 }
 
-impl From<trap::Label<Item>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5770,15 +5770,6 @@ impl From<trap::Label<Item>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -5788,9 +5779,18 @@ impl From<trap::Label<Item>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Item>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -5806,24 +5806,6 @@ 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
@@ -5833,6 +5815,15 @@ impl From<trap::Label<LabelableExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<LabelableExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Locatable
@@ -5842,6 +5833,15 @@ impl From<trap::Label<LabelableExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LetExpr {
     pub id: trap::TrapId<LetExpr>,
@@ -5873,24 +5873,6 @@ 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
@@ -5900,6 +5882,15 @@ impl From<trap::Label<LetExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<LetExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Locatable
@@ -5909,6 +5900,15 @@ impl From<trap::Label<LetExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LetStmt {
     pub id: trap::TrapId<LetStmt>,
@@ -5948,18 +5948,18 @@ impl trap::TrapClass for LetStmt {
     fn class_name() -> &'static str { "LetStmt" }
 }
 
-impl From<trap::Label<LetStmt>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LetStmt>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5975,9 +5975,9 @@ impl From<trap::Label<LetStmt>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<LetStmt>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme LetStmt is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6007,18 +6007,18 @@ impl trap::TrapClass for Lifetime {
     fn class_name() -> &'static str { "Lifetime" }
 }
 
-impl From<trap::Label<Lifetime>> for trap::Label<AstNode> {
+impl From<trap::Label<Lifetime>> for trap::Label<UseBoundGenericArg> {
     fn from(value: trap::Label<Lifetime>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of AstNode
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of UseBoundGenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Lifetime>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6034,9 +6034,9 @@ impl From<trap::Label<Lifetime>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Lifetime>> for trap::Label<UseBoundGenericArg> {
+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 UseBoundGenericArg
+        // SAFETY: this is safe because in the dbscheme Lifetime is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6066,24 +6066,6 @@ 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
@@ -6093,6 +6075,15 @@ impl From<trap::Label<LifetimeArg>> for trap::Label<GenericArg> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<LifetimeArg>) -> Self {
         // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Locatable
@@ -6102,6 +6093,15 @@ impl From<trap::Label<LifetimeArg>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LifetimeParam {
     pub id: trap::TrapId<LifetimeParam>,
@@ -6133,24 +6133,6 @@ 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
@@ -6160,6 +6142,15 @@ impl From<trap::Label<LifetimeParam>> for trap::Label<GenericParam> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<LifetimeParam>) -> Self {
         // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Locatable
@@ -6169,6 +6160,15 @@ impl From<trap::Label<LifetimeParam>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LiteralExpr {
     pub id: trap::TrapId<LiteralExpr>,
@@ -6196,24 +6196,6 @@ 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
@@ -6223,6 +6205,15 @@ impl From<trap::Label<LiteralExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<LiteralExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Locatable
@@ -6232,6 +6223,15 @@ impl From<trap::Label<LiteralExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LiteralPat {
     pub id: trap::TrapId<LiteralPat>,
@@ -6255,18 +6255,18 @@ impl trap::TrapClass for LiteralPat {
     fn class_name() -> &'static str { "LiteralPat" }
 }
 
-impl From<trap::Label<LiteralPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LiteralPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6282,9 +6282,9 @@ impl From<trap::Label<LiteralPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<LiteralPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme LiteralPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6314,24 +6314,6 @@ 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
@@ -6341,6 +6323,15 @@ impl From<trap::Label<MacroExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<MacroExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Locatable
@@ -6350,6 +6341,15 @@ impl From<trap::Label<MacroExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct MacroPat {
     pub id: trap::TrapId<MacroPat>,
@@ -6373,18 +6373,18 @@ impl trap::TrapClass for MacroPat {
     fn class_name() -> &'static str { "MacroPat" }
 }
 
-impl From<trap::Label<MacroPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6400,9 +6400,9 @@ impl From<trap::Label<MacroPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<MacroPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme MacroPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6432,18 +6432,18 @@ impl trap::TrapClass for MacroTypeRepr {
     fn class_name() -> &'static str { "MacroTypeRepr" }
 }
 
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6459,9 +6459,9 @@ impl From<trap::Label<MacroTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<MacroTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme MacroTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6499,24 +6499,6 @@ 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
@@ -6526,6 +6508,15 @@ impl From<trap::Label<MatchExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<MatchExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Locatable
@@ -6535,6 +6526,15 @@ impl From<trap::Label<MatchExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct NameRef {
     pub id: trap::TrapId<NameRef>,
@@ -6558,18 +6558,18 @@ impl trap::TrapClass for NameRef {
     fn class_name() -> &'static str { "NameRef" }
 }
 
-impl From<trap::Label<NameRef>> for trap::Label<AstNode> {
+impl From<trap::Label<NameRef>> for trap::Label<UseBoundGenericArg> {
     fn from(value: trap::Label<NameRef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of AstNode
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of UseBoundGenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<NameRef>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6585,9 +6585,9 @@ impl From<trap::Label<NameRef>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<NameRef>> for trap::Label<UseBoundGenericArg> {
+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 UseBoundGenericArg
+        // SAFETY: this is safe because in the dbscheme NameRef is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6613,18 +6613,18 @@ impl trap::TrapClass for NeverTypeRepr {
     fn class_name() -> &'static str { "NeverTypeRepr" }
 }
 
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6640,9 +6640,9 @@ impl From<trap::Label<NeverTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<NeverTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme NeverTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6680,24 +6680,6 @@ 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
@@ -6707,6 +6689,15 @@ impl From<trap::Label<OffsetOfExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<OffsetOfExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Locatable
@@ -6716,6 +6707,15 @@ impl From<trap::Label<OffsetOfExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct OrPat {
     pub id: trap::TrapId<OrPat>,
@@ -6739,18 +6739,18 @@ impl trap::TrapClass for OrPat {
     fn class_name() -> &'static str { "OrPat" }
 }
 
-impl From<trap::Label<OrPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<OrPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6766,9 +6766,9 @@ impl From<trap::Label<OrPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<OrPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme OrPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6806,18 +6806,18 @@ impl trap::TrapClass for Param {
     fn class_name() -> &'static str { "Param" }
 }
 
-impl From<trap::Label<Param>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of ParamBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Param>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6833,9 +6833,9 @@ impl From<trap::Label<Param>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Param>> for trap::Label<ParamBase> {
+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 ParamBase
+        // SAFETY: this is safe because in the dbscheme Param is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6869,24 +6869,6 @@ 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
@@ -6896,6 +6878,15 @@ impl From<trap::Label<ParenExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ParenExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Locatable
@@ -6905,6 +6896,15 @@ impl From<trap::Label<ParenExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ParenPat {
     pub id: trap::TrapId<ParenPat>,
@@ -6928,18 +6928,18 @@ impl trap::TrapClass for ParenPat {
     fn class_name() -> &'static str { "ParenPat" }
 }
 
-impl From<trap::Label<ParenPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParenPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6955,9 +6955,9 @@ impl From<trap::Label<ParenPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ParenPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme ParenPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6987,18 +6987,18 @@ impl trap::TrapClass for ParenTypeRepr {
     fn class_name() -> &'static str { "ParenTypeRepr" }
 }
 
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7014,9 +7014,9 @@ impl From<trap::Label<ParenTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ParenTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme ParenTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7032,18 +7032,18 @@ impl trap::TrapClass for PathAstNode {
     fn class_name() -> &'static str { "PathAstNode" }
 }
 
-impl From<trap::Label<PathAstNode>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Resolvable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathAstNode>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7059,9 +7059,9 @@ impl From<trap::Label<PathAstNode>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<PathAstNode>> for trap::Label<Resolvable> {
+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 Resolvable
+        // SAFETY: this is safe because in the dbscheme PathAstNode is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7077,24 +7077,6 @@ 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
@@ -7104,6 +7086,15 @@ impl From<trap::Label<PathExprBase>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<PathExprBase>) -> Self {
         // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Locatable
@@ -7113,6 +7104,15 @@ impl From<trap::Label<PathExprBase>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct PathTypeRepr {
     pub id: trap::TrapId<PathTypeRepr>,
@@ -7136,18 +7136,18 @@ impl trap::TrapClass for PathTypeRepr {
     fn class_name() -> &'static str { "PathTypeRepr" }
 }
 
-impl From<trap::Label<PathTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7163,9 +7163,9 @@ impl From<trap::Label<PathTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<PathTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme PathTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7203,24 +7203,6 @@ 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
@@ -7230,6 +7212,15 @@ impl From<trap::Label<PrefixExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<PrefixExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Locatable
@@ -7239,6 +7230,15 @@ impl From<trap::Label<PrefixExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct PtrTypeRepr {
     pub id: trap::TrapId<PtrTypeRepr>,
@@ -7270,18 +7270,18 @@ impl trap::TrapClass for PtrTypeRepr {
     fn class_name() -> &'static str { "PtrTypeRepr" }
 }
 
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7297,9 +7297,9 @@ impl From<trap::Label<PtrTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<PtrTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme PtrTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7341,24 +7341,6 @@ 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
@@ -7368,6 +7350,15 @@ impl From<trap::Label<RangeExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<RangeExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Locatable
@@ -7377,6 +7368,15 @@ impl From<trap::Label<RangeExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RangePat {
     pub id: trap::TrapId<RangePat>,
@@ -7408,18 +7408,18 @@ impl trap::TrapClass for RangePat {
     fn class_name() -> &'static str { "RangePat" }
 }
 
-impl From<trap::Label<RangePat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RangePat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7435,9 +7435,9 @@ impl From<trap::Label<RangePat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<RangePat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme RangePat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7467,24 +7467,6 @@ 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
@@ -7494,6 +7476,15 @@ impl From<trap::Label<RecordFieldList>> for trap::Label<FieldList> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<RecordFieldList>) -> Self {
         // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Locatable
@@ -7503,6 +7494,15 @@ impl From<trap::Label<RecordFieldList>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RefExpr {
     pub id: trap::TrapId<RefExpr>,
@@ -7542,24 +7542,6 @@ 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
@@ -7569,6 +7551,15 @@ impl From<trap::Label<RefExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<RefExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Locatable
@@ -7578,6 +7569,15 @@ impl From<trap::Label<RefExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RefPat {
     pub id: trap::TrapId<RefPat>,
@@ -7605,18 +7605,18 @@ impl trap::TrapClass for RefPat {
     fn class_name() -> &'static str { "RefPat" }
 }
 
-impl From<trap::Label<RefPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RefPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7632,9 +7632,9 @@ impl From<trap::Label<RefPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<RefPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme RefPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7672,18 +7672,18 @@ impl trap::TrapClass for RefTypeRepr {
     fn class_name() -> &'static str { "RefTypeRepr" }
 }
 
-impl From<trap::Label<RefTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RefTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7699,9 +7699,9 @@ impl From<trap::Label<RefTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<RefTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme RefTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7731,18 +7731,18 @@ impl trap::TrapClass for RestPat {
     fn class_name() -> &'static str { "RestPat" }
 }
 
-impl From<trap::Label<RestPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RestPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7758,9 +7758,9 @@ impl From<trap::Label<RestPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<RestPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme RestPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7794,24 +7794,6 @@ 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
@@ -7821,6 +7803,15 @@ impl From<trap::Label<ReturnExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<ReturnExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Locatable
@@ -7830,6 +7821,15 @@ impl From<trap::Label<ReturnExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct SelfParam {
     pub id: trap::TrapId<SelfParam>,
@@ -7873,18 +7873,18 @@ impl trap::TrapClass for SelfParam {
     fn class_name() -> &'static str { "SelfParam" }
 }
 
-impl From<trap::Label<SelfParam>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of ParamBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<SelfParam>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7900,9 +7900,9 @@ impl From<trap::Label<SelfParam>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<SelfParam>> for trap::Label<ParamBase> {
+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 ParamBase
+        // SAFETY: this is safe because in the dbscheme SelfParam is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7932,18 +7932,18 @@ impl trap::TrapClass for SlicePat {
     fn class_name() -> &'static str { "SlicePat" }
 }
 
-impl From<trap::Label<SlicePat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<SlicePat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7959,9 +7959,9 @@ impl From<trap::Label<SlicePat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<SlicePat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme SlicePat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7991,18 +7991,18 @@ impl trap::TrapClass for SliceTypeRepr {
     fn class_name() -> &'static str { "SliceTypeRepr" }
 }
 
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8018,9 +8018,9 @@ impl From<trap::Label<SliceTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<SliceTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme SliceTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8054,24 +8054,6 @@ 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
@@ -8081,6 +8063,15 @@ impl From<trap::Label<TryExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<TryExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Locatable
@@ -8090,6 +8081,15 @@ impl From<trap::Label<TryExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TupleExpr {
     pub id: trap::TrapId<TupleExpr>,
@@ -8117,24 +8117,6 @@ 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
@@ -8144,6 +8126,15 @@ impl From<trap::Label<TupleExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<TupleExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Locatable
@@ -8153,6 +8144,15 @@ impl From<trap::Label<TupleExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TupleFieldList {
     pub id: trap::TrapId<TupleFieldList>,
@@ -8176,24 +8176,6 @@ 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
@@ -8203,6 +8185,15 @@ impl From<trap::Label<TupleFieldList>> for trap::Label<FieldList> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<TupleFieldList>) -> Self {
         // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Locatable
@@ -8212,6 +8203,15 @@ impl From<trap::Label<TupleFieldList>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TuplePat {
     pub id: trap::TrapId<TuplePat>,
@@ -8235,18 +8235,18 @@ impl trap::TrapClass for TuplePat {
     fn class_name() -> &'static str { "TuplePat" }
 }
 
-impl From<trap::Label<TuplePat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TuplePat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8262,9 +8262,9 @@ impl From<trap::Label<TuplePat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<TuplePat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme TuplePat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8294,18 +8294,18 @@ impl trap::TrapClass for TupleTypeRepr {
     fn class_name() -> &'static str { "TupleTypeRepr" }
 }
 
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of TypeRepr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8321,9 +8321,9 @@ impl From<trap::Label<TupleTypeRepr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<TupleTypeRepr>> for trap::Label<TypeRepr> {
+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 TypeRepr
+        // SAFETY: this is safe because in the dbscheme TupleTypeRepr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8353,24 +8353,6 @@ 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
@@ -8380,6 +8362,15 @@ impl From<trap::Label<TypeArg>> for trap::Label<GenericArg> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<TypeArg>) -> Self {
         // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Locatable
@@ -8389,6 +8380,15 @@ impl From<trap::Label<TypeArg>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TypeParam {
     pub id: trap::TrapId<TypeParam>,
@@ -8424,24 +8424,6 @@ 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
@@ -8451,6 +8433,15 @@ impl From<trap::Label<TypeParam>> for trap::Label<GenericParam> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<TypeParam>) -> Self {
         // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Locatable
@@ -8460,6 +8451,15 @@ impl From<trap::Label<TypeParam>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct UnderscoreExpr {
     pub id: trap::TrapId<UnderscoreExpr>,
@@ -8483,24 +8483,6 @@ 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
@@ -8510,6 +8492,15 @@ impl From<trap::Label<UnderscoreExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<UnderscoreExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Locatable
@@ -8519,6 +8510,15 @@ impl From<trap::Label<UnderscoreExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Variant {
     pub id: trap::TrapId<Variant>,
@@ -8576,18 +8576,18 @@ impl From<trap::Label<Variant>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Variant>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Variant>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Variant is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8613,18 +8613,18 @@ impl trap::TrapClass for WildcardPat {
     fn class_name() -> &'static str { "WildcardPat" }
 }
 
-impl From<trap::Label<WildcardPat>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<WildcardPat>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8640,9 +8640,9 @@ impl From<trap::Label<WildcardPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<WildcardPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme WildcardPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8676,24 +8676,6 @@ 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
@@ -8703,6 +8685,15 @@ impl From<trap::Label<YeetExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<YeetExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Locatable
@@ -8712,6 +8703,15 @@ impl From<trap::Label<YeetExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct YieldExpr {
     pub id: trap::TrapId<YieldExpr>,
@@ -8739,24 +8739,6 @@ 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
@@ -8766,6 +8748,15 @@ impl From<trap::Label<YieldExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<YieldExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Locatable
@@ -8775,6 +8766,15 @@ impl From<trap::Label<YieldExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct BlockExpr {
     pub id: trap::TrapId<BlockExpr>,
@@ -8830,18 +8830,9 @@ impl trap::TrapClass for BlockExpr {
     fn class_name() -> &'static str { "BlockExpr" }
 }
 
-impl From<trap::Label<BlockExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8857,9 +8848,9 @@ impl From<trap::Label<BlockExpr>> for trap::Label<Expr> {
     }
 }
 
-impl From<trap::Label<BlockExpr>> for trap::Label<LabelableExpr> {
+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 LabelableExpr
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8875,6 +8866,15 @@ impl From<trap::Label<BlockExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct CallExpr {
     pub id: trap::TrapId<CallExpr>,
@@ -8906,15 +8906,6 @@ 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
@@ -8924,15 +8915,6 @@ impl From<trap::Label<CallExpr>> for trap::Label<CallExprBase> {
     }
 }
 
-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
@@ -8942,6 +8924,15 @@ impl From<trap::Label<CallExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<CallExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Locatable
@@ -8951,6 +8942,15 @@ impl From<trap::Label<CallExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Const {
     pub id: trap::TrapId<Const>,
@@ -8998,15 +8998,6 @@ 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
@@ -9025,6 +9016,15 @@ impl From<trap::Label<Const>> for trap::Label<AstNode> {
     }
 }
 
+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<Element> {
     fn from(value: trap::Label<Const>) -> Self {
         // SAFETY: this is safe because in the dbscheme Const is a subclass of Element
@@ -9043,18 +9043,18 @@ impl From<trap::Label<Const>> for trap::Label<Item> {
     }
 }
 
-impl From<trap::Label<Const>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Const>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9104,9 +9104,18 @@ impl trap::TrapClass for Enum {
     fn class_name() -> &'static str { "Enum" }
 }
 
-impl From<trap::Label<Enum>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -9122,24 +9131,6 @@ impl From<trap::Label<Enum>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -9149,9 +9140,18 @@ impl From<trap::Label<Enum>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Enum>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9193,9 +9193,18 @@ impl trap::TrapClass for ExternBlock {
     fn class_name() -> &'static str { "ExternBlock" }
 }
 
-impl From<trap::Label<ExternBlock>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -9211,24 +9220,6 @@ impl From<trap::Label<ExternBlock>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -9238,9 +9229,18 @@ impl From<trap::Label<ExternBlock>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ExternBlock>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9282,9 +9282,18 @@ impl trap::TrapClass for ExternCrate {
     fn class_name() -> &'static str { "ExternCrate" }
 }
 
-impl From<trap::Label<ExternCrate>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -9300,24 +9309,6 @@ impl From<trap::Label<ExternCrate>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -9327,9 +9318,18 @@ impl From<trap::Label<ExternCrate>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ExternCrate>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9411,15 +9411,6 @@ 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
@@ -9438,9 +9429,9 @@ impl From<trap::Label<Function>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Function>> for trap::Label<Callable> {
+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 Callable
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9474,18 +9465,27 @@ impl From<trap::Label<Function>> for trap::Label<Item> {
     }
 }
 
-impl From<trap::Label<Function>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Function is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Function>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9551,33 +9551,6 @@ 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
@@ -9587,15 +9560,6 @@ impl From<trap::Label<Impl>> for trap::Label<Item> {
     }
 }
 
-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
@@ -9605,6 +9569,42 @@ impl From<trap::Label<Impl>> for trap::Label<Stmt> {
     }
 }
 
+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<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<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<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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LoopingExpr {
     _unused: ()
@@ -9614,18 +9614,9 @@ impl trap::TrapClass for LoopingExpr {
     fn class_name() -> &'static str { "LoopingExpr" }
 }
 
-impl From<trap::Label<LoopingExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9641,9 +9632,9 @@ impl From<trap::Label<LoopingExpr>> for trap::Label<Expr> {
     }
 }
 
-impl From<trap::Label<LoopingExpr>> for trap::Label<LabelableExpr> {
+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 LabelableExpr
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9659,6 +9650,15 @@ impl From<trap::Label<LoopingExpr>> for trap::Label<Locatable> {
     }
 }
 
+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())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct MacroCall {
     pub id: trap::TrapId<MacroCall>,
@@ -9696,15 +9696,6 @@ 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
@@ -9723,6 +9714,15 @@ impl From<trap::Label<MacroCall>> for trap::Label<AstNode> {
     }
 }
 
+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<Element> {
     fn from(value: trap::Label<MacroCall>) -> Self {
         // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Element
@@ -9750,18 +9750,18 @@ impl From<trap::Label<MacroCall>> for trap::Label<Item> {
     }
 }
 
-impl From<trap::Label<MacroCall>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroCall>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9807,9 +9807,18 @@ impl trap::TrapClass for MacroDef {
     fn class_name() -> &'static str { "MacroDef" }
 }
 
-impl From<trap::Label<MacroDef>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -9825,24 +9834,6 @@ impl From<trap::Label<MacroDef>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -9852,9 +9843,18 @@ impl From<trap::Label<MacroDef>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<MacroDef>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9896,9 +9896,18 @@ impl trap::TrapClass for MacroRules {
     fn class_name() -> &'static str { "MacroRules" }
 }
 
-impl From<trap::Label<MacroRules>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -9914,24 +9923,6 @@ impl From<trap::Label<MacroRules>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -9941,9 +9932,18 @@ impl From<trap::Label<MacroRules>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<MacroRules>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -9989,15 +9989,6 @@ 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
@@ -10007,15 +9998,6 @@ impl From<trap::Label<MethodCallExpr>> for trap::Label<CallExprBase> {
     }
 }
 
-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
@@ -10025,6 +10007,15 @@ impl From<trap::Label<MethodCallExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<MethodCallExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Locatable
@@ -10034,6 +10025,15 @@ impl From<trap::Label<MethodCallExpr>> for trap::Label<Locatable> {
     }
 }
 
+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<Resolvable> {
     fn from(value: trap::Label<MethodCallExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Resolvable
@@ -10078,9 +10078,18 @@ impl trap::TrapClass for Module {
     fn class_name() -> &'static str { "Module" }
 }
 
-impl From<trap::Label<Module>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -10096,24 +10105,6 @@ impl From<trap::Label<Module>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -10123,9 +10114,18 @@ impl From<trap::Label<Module>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Module>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -10159,18 +10159,9 @@ impl trap::TrapClass for PathExpr {
     fn class_name() -> &'static str { "PathExpr" }
 }
 
-impl From<trap::Label<PathExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathExprBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10186,6 +10177,15 @@ impl From<trap::Label<PathExpr>> for trap::Label<Expr> {
     }
 }
 
+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<Locatable> {
     fn from(value: trap::Label<PathExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Locatable
@@ -10195,18 +10195,18 @@ impl From<trap::Label<PathExpr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<PathExpr>> for trap::Label<PathAstNode> {
+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 PathAstNode
+        // 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<PathExprBase> {
+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 PathExprBase
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathAstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10245,18 +10245,18 @@ impl trap::TrapClass for PathPat {
     fn class_name() -> &'static str { "PathPat" }
 }
 
-impl From<trap::Label<PathPat>> for trap::Label<AstNode> {
+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 AstNode
+        // 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<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10272,9 +10272,9 @@ impl From<trap::Label<PathPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<PathPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme PathPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10350,9 +10350,9 @@ impl trap::TrapClass for Static {
     fn class_name() -> &'static str { "Static" }
 }
 
-impl From<trap::Label<Static>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of ExternItem
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10368,18 +10368,18 @@ impl From<trap::Label<Static>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Static>> for trap::Label<Element> {
+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 Element
+        // 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<ExternItem> {
+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 ExternItem
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10395,18 +10395,18 @@ impl From<trap::Label<Static>> for trap::Label<Item> {
     }
 }
 
-impl From<trap::Label<Static>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Static>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Static is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10456,9 +10456,18 @@ impl trap::TrapClass for Struct {
     fn class_name() -> &'static str { "Struct" }
 }
 
-impl From<trap::Label<Struct>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -10474,24 +10483,6 @@ impl From<trap::Label<Struct>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -10501,9 +10492,18 @@ impl From<trap::Label<Struct>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Struct>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -10537,24 +10537,6 @@ impl trap::TrapClass for StructExpr {
     fn class_name() -> &'static str { "StructExpr" }
 }
 
-impl From<trap::Label<StructExpr>> for trap::Label<AstNode> {
-    fn from(value: trap::Label<StructExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of AstNode
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
-impl From<trap::Label<StructExpr>> for trap::Label<Element> {
-    fn from(value: trap::Label<StructExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Element
-        unsafe {
-            Self::from_untyped(value.as_untyped())
-        }
-    }
-}
-
 impl From<trap::Label<StructExpr>> for trap::Label<Expr> {
     fn from(value: trap::Label<StructExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Expr
@@ -10564,6 +10546,15 @@ impl From<trap::Label<StructExpr>> for trap::Label<Expr> {
     }
 }
 
+impl From<trap::Label<StructExpr>> for trap::Label<AstNode> {
+    fn from(value: trap::Label<StructExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of AstNode
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
 impl From<trap::Label<StructExpr>> for trap::Label<Locatable> {
     fn from(value: trap::Label<StructExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Locatable
@@ -10573,6 +10564,15 @@ impl From<trap::Label<StructExpr>> for trap::Label<Locatable> {
     }
 }
 
+impl From<trap::Label<StructExpr>> for trap::Label<Element> {
+    fn from(value: trap::Label<StructExpr>) -> Self {
+        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Element
+        unsafe {
+            Self::from_untyped(value.as_untyped())
+        }
+    }
+}
+
 impl From<trap::Label<StructExpr>> for trap::Label<PathAstNode> {
     fn from(value: trap::Label<StructExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of PathAstNode
@@ -10618,18 +10618,18 @@ impl trap::TrapClass for StructPat {
     fn class_name() -> &'static str { "StructPat" }
 }
 
-impl From<trap::Label<StructPat>> for trap::Label<AstNode> {
+impl From<trap::Label<StructPat>> for trap::Label<Pat> {
     fn from(value: trap::Label<StructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of AstNode
+        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of Pat
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructPat>> for trap::Label<Element> {
+impl From<trap::Label<StructPat>> for trap::Label<AstNode> {
     fn from(value: trap::Label<StructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10645,9 +10645,9 @@ impl From<trap::Label<StructPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<StructPat>> for trap::Label<Pat> {
+impl From<trap::Label<StructPat>> for trap::Label<Element> {
     fn from(value: trap::Label<StructPat>) -> Self {
-        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of Pat
+        // SAFETY: this is safe because in the dbscheme StructPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10727,9 +10727,18 @@ impl trap::TrapClass for Trait {
     fn class_name() -> &'static str { "Trait" }
 }
 
-impl From<trap::Label<Trait>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -10745,24 +10754,6 @@ impl From<trap::Label<Trait>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -10772,9 +10763,18 @@ impl From<trap::Label<Trait>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Trait>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -10824,9 +10824,18 @@ impl trap::TrapClass for TraitAlias {
     fn class_name() -> &'static str { "TraitAlias" }
 }
 
-impl From<trap::Label<TraitAlias>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -10842,24 +10851,6 @@ impl From<trap::Label<TraitAlias>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -10869,9 +10860,18 @@ impl From<trap::Label<TraitAlias>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<TraitAlias>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -10905,18 +10905,18 @@ impl trap::TrapClass for TupleStructPat {
     fn class_name() -> &'static str { "TupleStructPat" }
 }
 
-impl From<trap::Label<TupleStructPat>> for trap::Label<AstNode> {
+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 AstNode
+        // 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<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10932,9 +10932,9 @@ impl From<trap::Label<TupleStructPat>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<TupleStructPat>> for trap::Label<Pat> {
+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 Pat
+        // SAFETY: this is safe because in the dbscheme TupleStructPat is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11010,15 +11010,6 @@ 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
@@ -11037,6 +11028,15 @@ impl From<trap::Label<TypeAlias>> for trap::Label<AstNode> {
     }
 }
 
+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<Element> {
     fn from(value: trap::Label<TypeAlias>) -> Self {
         // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Element
@@ -11064,18 +11064,18 @@ impl From<trap::Label<TypeAlias>> for trap::Label<Item> {
     }
 }
 
-impl From<trap::Label<TypeAlias>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeAlias>> for trap::Label<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11125,9 +11125,18 @@ impl trap::TrapClass for Union {
     fn class_name() -> &'static str { "Union" }
 }
 
-impl From<trap::Label<Union>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -11143,24 +11152,6 @@ impl From<trap::Label<Union>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -11170,9 +11161,18 @@ impl From<trap::Label<Union>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Union>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -11210,9 +11210,18 @@ impl trap::TrapClass for Use {
     fn class_name() -> &'static str { "Use" }
 }
 
-impl From<trap::Label<Use>> for trap::Label<Addressable> {
+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 Addressable
+        // 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<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())
         }
@@ -11228,24 +11237,6 @@ impl From<trap::Label<Use>> for trap::Label<AstNode> {
     }
 }
 
-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
@@ -11255,9 +11246,18 @@ impl From<trap::Label<Use>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<Use>> for trap::Label<Stmt> {
+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 Stmt
+        // 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<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())
         }
@@ -11303,27 +11303,9 @@ impl trap::TrapClass for ForExpr {
     fn class_name() -> &'static str { "ForExpr" }
 }
 
-impl From<trap::Label<ForExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11339,6 +11321,24 @@ impl From<trap::Label<ForExpr>> for trap::Label<LabelableExpr> {
     }
 }
 
+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<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<Locatable> {
     fn from(value: trap::Label<ForExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Locatable
@@ -11348,9 +11348,9 @@ impl From<trap::Label<ForExpr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<ForExpr>> for trap::Label<LoopingExpr> {
+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 LoopingExpr
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11388,27 +11388,9 @@ impl trap::TrapClass for LoopExpr {
     fn class_name() -> &'static str { "LoopExpr" }
 }
 
-impl From<trap::Label<LoopExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11424,6 +11406,24 @@ impl From<trap::Label<LoopExpr>> for trap::Label<LabelableExpr> {
     }
 }
 
+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<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<Locatable> {
     fn from(value: trap::Label<LoopExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Locatable
@@ -11433,9 +11433,9 @@ impl From<trap::Label<LoopExpr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<LoopExpr>> for trap::Label<LoopingExpr> {
+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 LoopingExpr
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11477,27 +11477,9 @@ impl trap::TrapClass for WhileExpr {
     fn class_name() -> &'static str { "WhileExpr" }
 }
 
-impl From<trap::Label<WhileExpr>> for trap::Label<AstNode> {
+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 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
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11513,6 +11495,24 @@ impl From<trap::Label<WhileExpr>> for trap::Label<LabelableExpr> {
     }
 }
 
+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<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<Locatable> {
     fn from(value: trap::Label<WhileExpr>) -> Self {
         // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Locatable
@@ -11522,9 +11522,9 @@ impl From<trap::Label<WhileExpr>> for trap::Label<Locatable> {
     }
 }
 
-impl From<trap::Label<WhileExpr>> for trap::Label<LoopingExpr> {
+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 LoopingExpr
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }