diff --git a/misc/codegen/generators/rustgen.py b/misc/codegen/generators/rustgen.py
index b47e5cc4bd9d..38d2ae55d44b 100644
--- a/misc/codegen/generators/rustgen.py
+++ b/misc/codegen/generators/rustgen.py
@@ -96,7 +96,9 @@ def _get_class(self, name: str) -> rust.Class:
             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 8f599f1cc391..f4582cf85f43 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 36b202b412b08876b658a14a15f5b7e6ce3d2d9388bba9cd6fe75265855adfe6 36b202b412b08876b658a14a15f5b7e6ce3d2d9388bba9cd6fe75265855adfe6
+top.rs 22ca74a6a44e2984afdaffbc536d847296a79312d201b81948a32fe56064c8bf 22ca74a6a44e2984afdaffbc536d847296a79312d201b81948a32fe56064c8bf
diff --git a/rust/extractor/src/generated/top.rs b/rust/extractor/src/generated/top.rs
index 822ddf0c122b..4386de180168 100644
--- a/rust/extractor/src/generated/top.rs
+++ b/rust/extractor/src/generated/top.rs
@@ -131,18 +131,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())
         }
@@ -188,18 +188,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())
         }
@@ -225,18 +225,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())
         }
@@ -262,18 +262,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())
         }
@@ -312,18 +312,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())
         }
@@ -357,18 +357,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())
         }
@@ -407,18 +407,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())
         }
@@ -453,18 +453,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())
         }
@@ -489,18 +489,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())
         }
@@ -543,18 +543,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())
         }
@@ -593,18 +593,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())
         }
@@ -629,18 +629,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())
         }
@@ -679,18 +679,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())
         }
@@ -715,18 +715,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())
         }
@@ -769,18 +769,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())
         }
@@ -819,18 +819,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())
         }
@@ -855,18 +855,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())
         }
@@ -905,18 +905,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())
         }
@@ -941,18 +941,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())
         }
@@ -977,18 +977,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())
         }
@@ -1031,18 +1031,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())
         }
@@ -1067,18 +1067,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())
         }
@@ -1121,18 +1121,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())
         }
@@ -1157,18 +1157,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())
         }
@@ -1207,18 +1207,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())
         }
@@ -1243,18 +1243,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())
         }
@@ -1293,18 +1293,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())
         }
@@ -1347,18 +1347,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())
         }
@@ -1397,18 +1397,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())
         }
@@ -1447,18 +1447,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())
         }
@@ -1497,18 +1497,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())
         }
@@ -1551,18 +1551,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())
         }
@@ -1613,18 +1613,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())
         }
@@ -1667,18 +1667,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())
         }
@@ -1717,18 +1717,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())
         }
@@ -1779,18 +1779,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())
         }
@@ -1829,18 +1829,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())
         }
@@ -1865,18 +1865,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())
         }
@@ -1919,18 +1919,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())
         }
@@ -1969,18 +1969,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())
         }
@@ -2005,18 +2005,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())
         }
@@ -2059,18 +2059,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())
         }
@@ -2134,18 +2134,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())
         }
@@ -2184,18 +2184,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())
         }
@@ -2229,18 +2229,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())
         }
@@ -2279,18 +2279,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())
         }
@@ -2325,18 +2325,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())
         }
@@ -2379,18 +2379,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())
         }
@@ -2415,18 +2415,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())
         }
@@ -2473,18 +2473,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())
         }
@@ -2531,18 +2531,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())
         }
@@ -2589,18 +2589,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())
         }
@@ -2655,18 +2655,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())
         }
@@ -2713,18 +2713,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())
         }
@@ -2767,18 +2767,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())
         }
@@ -2803,18 +2803,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())
         }
@@ -2849,18 +2849,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())
         }
@@ -2907,18 +2907,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())
         }
@@ -2973,18 +2973,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())
         }
@@ -3023,18 +3023,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())
         }
@@ -3059,18 +3059,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())
         }
@@ -3095,18 +3095,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())
         }
@@ -3145,18 +3145,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())
         }
@@ -3207,18 +3207,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())
         }
@@ -3257,18 +3257,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())
         }
@@ -3307,18 +3307,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())
         }
@@ -3357,18 +3357,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())
         }
@@ -3407,18 +3407,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())
         }
@@ -3469,18 +3469,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())
         }
@@ -3518,36 +3518,36 @@ impl trap::TrapClass for ArrayExprInternal {
     fn class_name() -> &'static str { "ArrayExprInternal" }
 }
 
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ArrayExprInternal>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ArrayExprInternal is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3581,18 +3581,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())
         }
@@ -3608,9 +3608,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())
         }
@@ -3654,18 +3654,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())
         }
@@ -3717,18 +3717,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())
         }
@@ -3766,36 +3766,36 @@ impl trap::TrapClass for AsmExpr {
     fn class_name() -> &'static str { "AsmExpr" }
 }
 
-impl From<trap::Label<AsmExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AsmExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme AsmExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -3843,18 +3843,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())
         }
@@ -3906,18 +3906,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())
         }
@@ -3965,18 +3965,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())
         }
@@ -4032,18 +4032,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())
         }
@@ -4091,18 +4091,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())
         }
@@ -4160,36 +4160,36 @@ impl trap::TrapClass for AssocTypeArg {
     fn class_name() -> &'static str { "AssocTypeArg" }
 }
 
-impl From<trap::Label<AssocTypeArg>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of GenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AssocTypeArg>> for trap::Label<Element> {
+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 Element
+        // 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<GenericArg> {
+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 GenericArg
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme AssocTypeArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4223,36 +4223,36 @@ impl trap::TrapClass for AwaitExpr {
     fn class_name() -> &'static str { "AwaitExpr" }
 }
 
-impl From<trap::Label<AwaitExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<AwaitExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme AwaitExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4286,36 +4286,36 @@ impl trap::TrapClass for BecomeExpr {
     fn class_name() -> &'static str { "BecomeExpr" }
 }
 
-impl From<trap::Label<BecomeExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BecomeExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme BecomeExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4357,36 +4357,36 @@ impl trap::TrapClass for BinaryExpr {
     fn class_name() -> &'static str { "BinaryExpr" }
 }
 
-impl From<trap::Label<BinaryExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BinaryExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme BinaryExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4416,18 +4416,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())
         }
@@ -4443,9 +4443,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())
         }
@@ -4483,36 +4483,36 @@ impl trap::TrapClass for BreakExpr {
     fn class_name() -> &'static str { "BreakExpr" }
 }
 
-impl From<trap::Label<BreakExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BreakExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme BreakExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4528,36 +4528,36 @@ impl trap::TrapClass for CallExprBase {
     fn class_name() -> &'static str { "CallExprBase" }
 }
 
-impl From<trap::Label<CallExprBase>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<CallExprBase>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme CallExprBase is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4595,36 +4595,36 @@ impl trap::TrapClass for CastExpr {
     fn class_name() -> &'static str { "CastExpr" }
 }
 
-impl From<trap::Label<CastExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<CastExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme CastExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4690,45 +4690,45 @@ impl trap::TrapClass for ClosureExpr {
     fn class_name() -> &'static str { "ClosureExpr" }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // 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<Callable> {
+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 Callable
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<Expr> {
+impl From<trap::Label<ClosureExpr>> for trap::Label<Element> {
     fn from(value: trap::Label<ClosureExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Expr
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ClosureExpr>> for trap::Label<Locatable> {
+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 Locatable
+        // SAFETY: this is safe because in the dbscheme ClosureExpr is a subclass of Callable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4756,18 +4756,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())
         }
@@ -4783,9 +4783,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())
         }
@@ -4815,36 +4815,36 @@ impl trap::TrapClass for ConstArg {
     fn class_name() -> &'static str { "ConstArg" }
 }
 
-impl From<trap::Label<ConstArg>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of GenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ConstArg>> for trap::Label<Element> {
+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 Element
+        // 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<GenericArg> {
+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 GenericArg
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ConstArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -4878,18 +4878,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())
         }
@@ -4905,9 +4905,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())
         }
@@ -4953,36 +4953,36 @@ impl trap::TrapClass for ConstParam {
     fn class_name() -> &'static str { "ConstParam" }
 }
 
-impl From<trap::Label<ConstParam>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of GenericParam
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ConstParam>> for trap::Label<Element> {
+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 Element
+        // 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<GenericParam> {
+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 GenericParam
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ConstParam is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5016,36 +5016,36 @@ impl trap::TrapClass for ContinueExpr {
     fn class_name() -> &'static str { "ContinueExpr" }
 }
 
-impl From<trap::Label<ContinueExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ContinueExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ContinueExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5075,18 +5075,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())
         }
@@ -5102,9 +5102,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())
         }
@@ -5134,18 +5134,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())
         }
@@ -5161,9 +5161,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())
         }
@@ -5201,36 +5201,36 @@ impl trap::TrapClass for FieldExpr {
     fn class_name() -> &'static str { "FieldExpr" }
 }
 
-impl From<trap::Label<FieldExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<FieldExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme FieldExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5280,18 +5280,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())
         }
@@ -5307,9 +5307,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())
         }
@@ -5343,18 +5343,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())
         }
@@ -5370,9 +5370,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())
         }
@@ -5410,36 +5410,36 @@ impl trap::TrapClass for FormatArgsExpr {
     fn class_name() -> &'static str { "FormatArgsExpr" }
 }
 
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<FormatArgsExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme FormatArgsExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5485,18 +5485,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())
         }
@@ -5512,9 +5512,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())
         }
@@ -5556,36 +5556,36 @@ impl trap::TrapClass for IfExpr {
     fn class_name() -> &'static str { "IfExpr" }
 }
 
-impl From<trap::Label<IfExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<IfExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme IfExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5615,18 +5615,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())
         }
@@ -5642,9 +5642,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())
         }
@@ -5682,36 +5682,36 @@ impl trap::TrapClass for IndexExpr {
     fn class_name() -> &'static str { "IndexExpr" }
 }
 
-impl From<trap::Label<IndexExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<IndexExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme IndexExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5737,18 +5737,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())
         }
@@ -5764,9 +5764,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())
         }
@@ -5782,9 +5782,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())
         }
@@ -5800,27 +5800,27 @@ impl From<trap::Label<Item>> for trap::Label<AstNode> {
     }
 }
 
-impl From<trap::Label<Item>> for trap::Label<Element> {
+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 Element
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Item>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Item is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5836,36 +5836,36 @@ impl trap::TrapClass for LabelableExpr {
     fn class_name() -> &'static str { "LabelableExpr" }
 }
 
-impl From<trap::Label<LabelableExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LabelableExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LabelableExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5903,36 +5903,36 @@ impl trap::TrapClass for LetExpr {
     fn class_name() -> &'static str { "LetExpr" }
 }
 
-impl From<trap::Label<LetExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LetExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LetExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -5978,18 +5978,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())
         }
@@ -6005,9 +6005,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())
         }
@@ -6037,18 +6037,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())
         }
@@ -6064,9 +6064,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())
         }
@@ -6096,36 +6096,36 @@ impl trap::TrapClass for LifetimeArg {
     fn class_name() -> &'static str { "LifetimeArg" }
 }
 
-impl From<trap::Label<LifetimeArg>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of GenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LifetimeArg>> for trap::Label<Element> {
+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 Element
+        // 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<GenericArg> {
+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 GenericArg
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LifetimeArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6163,36 +6163,36 @@ impl trap::TrapClass for LifetimeParam {
     fn class_name() -> &'static str { "LifetimeParam" }
 }
 
-impl From<trap::Label<LifetimeParam>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of GenericParam
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LifetimeParam>> for trap::Label<Element> {
+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 Element
+        // 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<GenericParam> {
+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 GenericParam
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LifetimeParam is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6226,36 +6226,36 @@ impl trap::TrapClass for LiteralExpr {
     fn class_name() -> &'static str { "LiteralExpr" }
 }
 
-impl From<trap::Label<LiteralExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LiteralExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LiteralExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6285,18 +6285,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())
         }
@@ -6312,9 +6312,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())
         }
@@ -6344,36 +6344,36 @@ impl trap::TrapClass for MacroExpr {
     fn class_name() -> &'static str { "MacroExpr" }
 }
 
-impl From<trap::Label<MacroExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme MacroExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6403,18 +6403,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())
         }
@@ -6430,9 +6430,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())
         }
@@ -6462,18 +6462,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())
         }
@@ -6489,9 +6489,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())
         }
@@ -6529,36 +6529,36 @@ impl trap::TrapClass for MatchExpr {
     fn class_name() -> &'static str { "MatchExpr" }
 }
 
-impl From<trap::Label<MatchExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MatchExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme MatchExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6588,18 +6588,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())
         }
@@ -6615,9 +6615,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())
         }
@@ -6643,18 +6643,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())
         }
@@ -6670,9 +6670,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())
         }
@@ -6710,36 +6710,36 @@ impl trap::TrapClass for OffsetOfExpr {
     fn class_name() -> &'static str { "OffsetOfExpr" }
 }
 
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<OffsetOfExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme OffsetOfExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6769,18 +6769,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())
         }
@@ -6796,9 +6796,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())
         }
@@ -6836,18 +6836,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())
         }
@@ -6863,9 +6863,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())
         }
@@ -6899,36 +6899,36 @@ impl trap::TrapClass for ParenExpr {
     fn class_name() -> &'static str { "ParenExpr" }
 }
 
-impl From<trap::Label<ParenExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ParenExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ParenExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -6958,18 +6958,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())
         }
@@ -6985,9 +6985,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())
         }
@@ -7017,18 +7017,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())
         }
@@ -7044,9 +7044,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())
         }
@@ -7062,18 +7062,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())
         }
@@ -7089,9 +7089,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())
         }
@@ -7107,36 +7107,36 @@ impl trap::TrapClass for PathExprBase {
     fn class_name() -> &'static str { "PathExprBase" }
 }
 
-impl From<trap::Label<PathExprBase>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathExprBase>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme PathExprBase is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7166,18 +7166,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())
         }
@@ -7193,9 +7193,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())
         }
@@ -7233,36 +7233,36 @@ impl trap::TrapClass for PrefixExpr {
     fn class_name() -> &'static str { "PrefixExpr" }
 }
 
-impl From<trap::Label<PrefixExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PrefixExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme PrefixExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7300,18 +7300,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())
         }
@@ -7327,9 +7327,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())
         }
@@ -7371,36 +7371,36 @@ impl trap::TrapClass for RangeExpr {
     fn class_name() -> &'static str { "RangeExpr" }
 }
 
-impl From<trap::Label<RangeExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RangeExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme RangeExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7438,18 +7438,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())
         }
@@ -7465,9 +7465,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())
         }
@@ -7497,36 +7497,36 @@ impl trap::TrapClass for RecordFieldList {
     fn class_name() -> &'static str { "RecordFieldList" }
 }
 
-impl From<trap::Label<RecordFieldList>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of FieldList
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RecordFieldList>> for trap::Label<Element> {
+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 Element
+        // 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<FieldList> {
+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 FieldList
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme RecordFieldList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7572,36 +7572,36 @@ impl trap::TrapClass for RefExpr {
     fn class_name() -> &'static str { "RefExpr" }
 }
 
-impl From<trap::Label<RefExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<RefExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme RefExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7635,18 +7635,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())
         }
@@ -7662,9 +7662,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())
         }
@@ -7702,18 +7702,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())
         }
@@ -7729,9 +7729,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())
         }
@@ -7761,18 +7761,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())
         }
@@ -7788,9 +7788,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())
         }
@@ -7824,36 +7824,36 @@ impl trap::TrapClass for ReturnExpr {
     fn class_name() -> &'static str { "ReturnExpr" }
 }
 
-impl From<trap::Label<ReturnExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ReturnExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme ReturnExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -7903,18 +7903,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())
         }
@@ -7930,9 +7930,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())
         }
@@ -7962,18 +7962,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())
         }
@@ -7989,9 +7989,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())
         }
@@ -8021,18 +8021,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())
         }
@@ -8048,9 +8048,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())
         }
@@ -8084,36 +8084,36 @@ impl trap::TrapClass for TryExpr {
     fn class_name() -> &'static str { "TryExpr" }
 }
 
-impl From<trap::Label<TryExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TryExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme TryExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8147,36 +8147,36 @@ impl trap::TrapClass for TupleExpr {
     fn class_name() -> &'static str { "TupleExpr" }
 }
 
-impl From<trap::Label<TupleExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TupleExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme TupleExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8206,36 +8206,36 @@ impl trap::TrapClass for TupleFieldList {
     fn class_name() -> &'static str { "TupleFieldList" }
 }
 
-impl From<trap::Label<TupleFieldList>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of FieldList
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TupleFieldList>> for trap::Label<Element> {
+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 Element
+        // 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<FieldList> {
+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 FieldList
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme TupleFieldList is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8265,18 +8265,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())
         }
@@ -8292,9 +8292,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())
         }
@@ -8324,18 +8324,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())
         }
@@ -8351,9 +8351,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())
         }
@@ -8383,36 +8383,36 @@ impl trap::TrapClass for TypeArg {
     fn class_name() -> &'static str { "TypeArg" }
 }
 
-impl From<trap::Label<TypeArg>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of GenericArg
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeArg>> for trap::Label<Element> {
+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 Element
+        // 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<GenericArg> {
+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 GenericArg
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeArg is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8454,36 +8454,36 @@ impl trap::TrapClass for TypeParam {
     fn class_name() -> &'static str { "TypeParam" }
 }
 
-impl From<trap::Label<TypeParam>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of GenericParam
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeParam>> for trap::Label<Element> {
+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 Element
+        // 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<GenericParam> {
+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 GenericParam
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme TypeParam is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8513,36 +8513,36 @@ impl trap::TrapClass for UnderscoreExpr {
     fn class_name() -> &'static str { "UnderscoreExpr" }
 }
 
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<UnderscoreExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme UnderscoreExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8606,18 +8606,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())
         }
@@ -8643,18 +8643,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())
         }
@@ -8670,9 +8670,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())
         }
@@ -8706,36 +8706,36 @@ impl trap::TrapClass for YeetExpr {
     fn class_name() -> &'static str { "YeetExpr" }
 }
 
-impl From<trap::Label<YeetExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<YeetExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme YeetExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8769,36 +8769,36 @@ impl trap::TrapClass for YieldExpr {
     fn class_name() -> &'static str { "YieldExpr" }
 }
 
-impl From<trap::Label<YieldExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<YieldExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme YieldExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8860,45 +8860,45 @@ 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
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BlockExpr>> for trap::Label<Element> {
+impl From<trap::Label<BlockExpr>> for trap::Label<Expr> {
     fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<BlockExpr>> for trap::Label<Expr> {
+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 Expr
+        // 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<LabelableExpr> {
+impl From<trap::Label<BlockExpr>> for trap::Label<Locatable> {
     fn from(value: trap::Label<BlockExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of LabelableExpr
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme BlockExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -8936,45 +8936,45 @@ impl trap::TrapClass for CallExpr {
     fn class_name() -> &'static str { "CallExpr" }
 }
 
-impl From<trap::Label<CallExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of CallExprBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<CallExpr>> for trap::Label<CallExprBase> {
+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 CallExprBase
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<CallExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme CallExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9028,27 +9028,27 @@ impl trap::TrapClass for Const {
     fn class_name() -> &'static str { "Const" }
 }
 
-impl From<trap::Label<Const>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of AssocItem
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Const>> for trap::Label<AssocItem> {
+impl From<trap::Label<Const>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Const>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Const is a subclass of AssocItem
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Const>> for trap::Label<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 AstNode
+        // SAFETY: this is safe because in the dbscheme Const is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9073,18 +9073,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())
         }
@@ -9134,54 +9134,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Enum>> for trap::Label<Element> {
+impl From<trap::Label<Enum>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Enum>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Enum>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Enum>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Enum is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9223,54 +9223,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternBlock>> for trap::Label<Element> {
+impl From<trap::Label<ExternBlock>> for trap::Label<AstNode> {
     fn from(value: trap::Label<ExternBlock>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternBlock>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternBlock>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme ExternBlock is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9312,54 +9312,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternCrate>> for trap::Label<Element> {
+impl From<trap::Label<ExternCrate>> for trap::Label<AstNode> {
     fn from(value: trap::Label<ExternCrate>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternCrate>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ExternCrate>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme ExternCrate is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9441,15 +9441,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
@@ -9468,9 +9459,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())
         }
@@ -9504,18 +9495,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())
         }
@@ -9581,54 +9581,54 @@ impl trap::TrapClass for Impl {
     fn class_name() -> &'static str { "Impl" }
 }
 
-impl From<trap::Label<Impl>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Item
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Impl>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Impl>> for trap::Label<Element> {
+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 Element
+        // 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<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 Item
+        // 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<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Impl is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9644,45 +9644,45 @@ 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
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LoopingExpr>> for trap::Label<Element> {
+impl From<trap::Label<LoopingExpr>> for trap::Label<Expr> {
     fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LoopingExpr>> for trap::Label<Expr> {
+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 Expr
+        // 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<LabelableExpr> {
+impl From<trap::Label<LoopingExpr>> for trap::Label<Locatable> {
     fn from(value: trap::Label<LoopingExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of LabelableExpr
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme LoopingExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9726,27 +9726,27 @@ impl trap::TrapClass for MacroCall {
     fn class_name() -> &'static str { "MacroCall" }
 }
 
-impl From<trap::Label<MacroCall>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AssocItem
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroCall>> for trap::Label<AssocItem> {
+impl From<trap::Label<MacroCall>> for trap::Label<AstNode> {
     fn from(value: trap::Label<MacroCall>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AssocItem
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroCall>> for trap::Label<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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroCall is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9780,18 +9780,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())
         }
@@ -9837,54 +9837,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroDef>> for trap::Label<Element> {
+impl From<trap::Label<MacroDef>> for trap::Label<AstNode> {
     fn from(value: trap::Label<MacroDef>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroDef>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroDef>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme MacroDef is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -9926,54 +9926,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroRules>> for trap::Label<Element> {
+impl From<trap::Label<MacroRules>> for trap::Label<AstNode> {
     fn from(value: trap::Label<MacroRules>) -> Self {
-        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroRules>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MacroRules>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme MacroRules is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10019,45 +10019,45 @@ impl trap::TrapClass for MethodCallExpr {
     fn class_name() -> &'static str { "MethodCallExpr" }
 }
 
-impl From<trap::Label<MethodCallExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of CallExprBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MethodCallExpr>> for trap::Label<CallExprBase> {
+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 CallExprBase
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MethodCallExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<MethodCallExpr>> for trap::Label<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 Locatable
+        // SAFETY: this is safe because in the dbscheme MethodCallExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10108,54 +10108,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Module>> for trap::Label<Element> {
+impl From<trap::Label<Module>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Module>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Module is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Module>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Module>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Module is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10189,27 +10189,27 @@ 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
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of PathExprBase
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathExpr>> for trap::Label<Element> {
+impl From<trap::Label<PathExpr>> for trap::Label<Expr> {
     fn from(value: trap::Label<PathExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<PathExpr>> for trap::Label<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 Expr
+        // SAFETY: this is safe because in the dbscheme PathExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10225,18 +10225,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())
         }
@@ -10275,18 +10275,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())
         }
@@ -10302,9 +10302,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())
         }
@@ -10380,9 +10380,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())
         }
@@ -10398,18 +10398,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())
         }
@@ -10425,18 +10425,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())
         }
@@ -10486,54 +10486,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Struct>> for trap::Label<Element> {
+impl From<trap::Label<Struct>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Struct>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Struct>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Struct>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Struct is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10567,36 +10567,36 @@ impl trap::TrapClass for StructExpr {
     fn class_name() -> &'static str { "StructExpr" }
 }
 
-impl From<trap::Label<StructExpr>> for trap::Label<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Expr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<StructExpr>> for trap::Label<Element> {
+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 Element
+        // 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<Expr> {
+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 Expr
+        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-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 Locatable
+        // SAFETY: this is safe because in the dbscheme StructExpr is a subclass of Element
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10648,18 +10648,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())
         }
@@ -10675,9 +10675,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())
         }
@@ -10757,54 +10757,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Trait>> for trap::Label<Element> {
+impl From<trap::Label<Trait>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Trait>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Trait>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Trait>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Trait is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10854,54 +10854,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TraitAlias>> for trap::Label<Element> {
+impl From<trap::Label<TraitAlias>> for trap::Label<AstNode> {
     fn from(value: trap::Label<TraitAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TraitAlias>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TraitAlias>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme TraitAlias is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -10935,18 +10935,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())
         }
@@ -10962,9 +10962,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())
         }
@@ -11040,27 +11040,27 @@ impl trap::TrapClass for TypeAlias {
     fn class_name() -> &'static str { "TypeAlias" }
 }
 
-impl From<trap::Label<TypeAlias>> for trap::Label<Addressable> {
+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 Addressable
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AssocItem
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeAlias>> for trap::Label<AssocItem> {
+impl From<trap::Label<TypeAlias>> for trap::Label<AstNode> {
     fn from(value: trap::Label<TypeAlias>) -> Self {
-        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AssocItem
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<TypeAlias>> for trap::Label<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 AstNode
+        // SAFETY: this is safe because in the dbscheme TypeAlias is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11094,18 +11094,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())
         }
@@ -11155,54 +11155,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Union>> for trap::Label<Element> {
+impl From<trap::Label<Union>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Union>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Union is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Union>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Union>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Union is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11240,54 +11240,54 @@ 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<AstNode> {
+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 AstNode
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Stmt
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Use>> for trap::Label<Element> {
+impl From<trap::Label<Use>> for trap::Label<AstNode> {
     fn from(value: trap::Label<Use>) -> Self {
-        // SAFETY: this is safe because in the dbscheme Use is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Use>> for trap::Label<Item> {
+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 Item
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Locatable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<Use>> for trap::Label<Locatable> {
+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 Locatable
+        // 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<Stmt> {
+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 Stmt
+        // SAFETY: this is safe because in the dbscheme Use is a subclass of Addressable
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11333,18 +11333,18 @@ 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
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<ForExpr>> for trap::Label<Element> {
+impl From<trap::Label<ForExpr>> for trap::Label<LabelableExpr> {
     fn from(value: trap::Label<ForExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11360,9 +11360,9 @@ impl From<trap::Label<ForExpr>> for trap::Label<Expr> {
     }
 }
 
-impl From<trap::Label<ForExpr>> for trap::Label<LabelableExpr> {
+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 LabelableExpr
+        // SAFETY: this is safe because in the dbscheme ForExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11378,9 +11378,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())
         }
@@ -11418,18 +11418,18 @@ 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
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<LoopExpr>> for trap::Label<Element> {
+impl From<trap::Label<LoopExpr>> for trap::Label<LabelableExpr> {
     fn from(value: trap::Label<LoopExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11445,9 +11445,9 @@ impl From<trap::Label<LoopExpr>> for trap::Label<Expr> {
     }
 }
 
-impl From<trap::Label<LoopExpr>> for trap::Label<LabelableExpr> {
+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 LabelableExpr
+        // SAFETY: this is safe because in the dbscheme LoopExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11463,9 +11463,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())
         }
@@ -11507,18 +11507,18 @@ 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
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LoopingExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
     }
 }
 
-impl From<trap::Label<WhileExpr>> for trap::Label<Element> {
+impl From<trap::Label<WhileExpr>> for trap::Label<LabelableExpr> {
     fn from(value: trap::Label<WhileExpr>) -> Self {
-        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of Element
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of LabelableExpr
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11534,9 +11534,9 @@ impl From<trap::Label<WhileExpr>> for trap::Label<Expr> {
     }
 }
 
-impl From<trap::Label<WhileExpr>> for trap::Label<LabelableExpr> {
+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 LabelableExpr
+        // SAFETY: this is safe because in the dbscheme WhileExpr is a subclass of AstNode
         unsafe {
             Self::from_untyped(value.as_untyped())
         }
@@ -11552,9 +11552,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())
         }