// generated by codegen, do not edit

#![cfg_attr(any(), rustfmt::skip)]

use crate::trap;

#[derive(Debug)]

pub struct Element {

_unused: ()

}

impl trap::TrapClass for Element {

fn class_name() -> &'static str { "Element" }

}

#[derive(Debug)]

pub struct Locatable {

_unused: ()

}

impl trap::TrapClass for Locatable {

fn class_name() -> &'static str { "Locatable" }

}

impl From<trap::Label<Locatable>> for trap::Label<Element> {

fn from(value: trap::Label<Locatable>) -> Self {

// SAFETY: this is safe because in the dbscheme Locatable is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Unextracted {

_unused: ()

}

impl trap::TrapClass for Unextracted {

fn class_name() -> &'static str { "Unextracted" }

}

impl From<trap::Label<Unextracted>> for trap::Label<Element> {

fn from(value: trap::Label<Unextracted>) -> Self {

// SAFETY: this is safe because in the dbscheme Unextracted is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct AstNode {

_unused: ()

}

impl trap::TrapClass for AstNode {

fn class_name() -> &'static str { "AstNode" }

}

impl From<trap::Label<AstNode>> for trap::Label<Element> {

fn from(value: trap::Label<AstNode>) -> Self {

// SAFETY: this is safe because in the dbscheme AstNode is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<AstNode>> for trap::Label<Locatable> {

fn from(value: trap::Label<AstNode>) -> Self {

// SAFETY: this is safe because in the dbscheme AstNode is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Missing {

pub id: trap::TrapId<Missing>,

}

impl trap::TrapEntry for Missing {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("missings", vec![id.into()]);

}

}

impl trap::TrapClass for Missing {

fn class_name() -> &'static str { "Missing" }

}

impl From<trap::Label<Missing>> for trap::Label<Element> {

fn from(value: trap::Label<Missing>) -> Self {

// SAFETY: this is safe because in the dbscheme Missing is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Missing>> for trap::Label<Unextracted> {

fn from(value: trap::Label<Missing>) -> Self {

// SAFETY: this is safe because in the dbscheme Missing is a subclass of Unextracted

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Unimplemented {

pub id: trap::TrapId<Unimplemented>,

}

impl trap::TrapEntry for Unimplemented {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("unimplementeds", vec![id.into()]);

}

}

impl trap::TrapClass for Unimplemented {

fn class_name() -> &'static str { "Unimplemented" }

}

impl From<trap::Label<Unimplemented>> for trap::Label<Element> {

fn from(value: trap::Label<Unimplemented>) -> Self {

// SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Unimplemented>> for trap::Label<Unextracted> {

fn from(value: trap::Label<Unimplemented>) -> Self {

// SAFETY: this is safe because in the dbscheme Unimplemented is a subclass of Unextracted

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Abi {

pub id: trap::TrapId<Abi>,

pub abi_string: Option<String>,

}

impl trap::TrapEntry for Abi {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("abis", vec![id.into()]);

if let Some(v) = self.abi_string {

out.add_tuple("abi_abi_strings", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for Abi {

fn class_name() -> &'static str { "Abi" }

}

impl From<trap::Label<Abi>> for trap::Label<AstNode> {

fn from(value: trap::Label<Abi>) -> Self {

// SAFETY: this is safe because in the dbscheme Abi is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Abi>> for trap::Label<Element> {

fn from(value: trap::Label<Abi>) -> Self {

// SAFETY: this is safe because in the dbscheme Abi is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Abi>> for trap::Label<Locatable> {

fn from(value: trap::Label<Abi>) -> Self {

// SAFETY: this is safe because in the dbscheme Abi is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct ArgList {

pub id: trap::TrapId<ArgList>,

pub args: Vec<trap::Label<Expr>>,

}

impl trap::TrapEntry for ArgList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("arg_lists", vec![id.into()]);

for (i, v) in self.args.into_iter().enumerate() {

out.add_tuple("arg_list_args", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for ArgList {

fn class_name() -> &'static str { "ArgList" }

}

impl From<trap::Label<ArgList>> for trap::Label<AstNode> {

fn from(value: trap::Label<ArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme ArgList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ArgList>> for trap::Label<Element> {

fn from(value: trap::Label<ArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme ArgList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ArgList>> for trap::Label<Locatable> {

fn from(value: trap::Label<ArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme ArgList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct AssocItem {

_unused: ()

}

impl trap::TrapClass for AssocItem {

fn class_name() -> &'static str { "AssocItem" }

}

impl From<trap::Label<AssocItem>> for trap::Label<AstNode> {

fn from(value: trap::Label<AssocItem>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItem is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<AssocItem>> for trap::Label<Element> {

fn from(value: trap::Label<AssocItem>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<AssocItem>> for trap::Label<Locatable> {

fn from(value: trap::Label<AssocItem>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItem is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct AssocItemList {

pub id: trap::TrapId<AssocItemList>,

pub assoc_items: Vec<trap::Label<AssocItem>>,

pub attrs: Vec<trap::Label<Attr>>,

}

impl trap::TrapEntry for AssocItemList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("assoc_item_lists", vec![id.into()]);

for (i, v) in self.assoc_items.into_iter().enumerate() {

out.add_tuple("assoc_item_list_assoc_items", vec![id.into(), i.into(), v.into()]);

}

for (i, v) in self.attrs.into_iter().enumerate() {

out.add_tuple("assoc_item_list_attrs", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for AssocItemList {

fn class_name() -> &'static str { "AssocItemList" }

}

impl From<trap::Label<AssocItemList>> for trap::Label<AstNode> {

fn from(value: trap::Label<AssocItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<AssocItemList>> for trap::Label<Element> {

fn from(value: trap::Label<AssocItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<AssocItemList>> for trap::Label<Locatable> {

fn from(value: trap::Label<AssocItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme AssocItemList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Attr {

pub id: trap::TrapId<Attr>,

pub meta: Option<trap::Label<Meta>>,

}

impl trap::TrapEntry for Attr {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("attrs", vec![id.into()]);

if let Some(v) = self.meta {

out.add_tuple("attr_meta", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for Attr {

fn class_name() -> &'static str { "Attr" }

}

impl From<trap::Label<Attr>> for trap::Label<AstNode> {

fn from(value: trap::Label<Attr>) -> Self {

// SAFETY: this is safe because in the dbscheme Attr is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Attr>> for trap::Label<Element> {

fn from(value: trap::Label<Attr>) -> Self {

// SAFETY: this is safe because in the dbscheme Attr is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Attr>> for trap::Label<Locatable> {

fn from(value: trap::Label<Attr>) -> Self {

// SAFETY: this is safe because in the dbscheme Attr is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Callable {

_unused: ()

}

impl trap::TrapClass for Callable {

fn class_name() -> &'static str { "Callable" }

}

impl From<trap::Label<Callable>> for trap::Label<AstNode> {

fn from(value: trap::Label<Callable>) -> Self {

// SAFETY: this is safe because in the dbscheme Callable is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Callable>> for trap::Label<Element> {

fn from(value: trap::Label<Callable>) -> Self {

// SAFETY: this is safe because in the dbscheme Callable is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Callable>> for trap::Label<Locatable> {

fn from(value: trap::Label<Callable>) -> Self {

// SAFETY: this is safe because in the dbscheme Callable is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct ClosureBinder {

pub id: trap::TrapId<ClosureBinder>,

pub generic_param_list: Option<trap::Label<GenericParamList>>,

}

impl trap::TrapEntry for ClosureBinder {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("closure_binders", vec![id.into()]);

if let Some(v) = self.generic_param_list {

out.add_tuple("closure_binder_generic_param_lists", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for ClosureBinder {

fn class_name() -> &'static str { "ClosureBinder" }

}

impl From<trap::Label<ClosureBinder>> for trap::Label<AstNode> {

fn from(value: trap::Label<ClosureBinder>) -> Self {

// SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ClosureBinder>> for trap::Label<Element> {

fn from(value: trap::Label<ClosureBinder>) -> Self {

// SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ClosureBinder>> for trap::Label<Locatable> {

fn from(value: trap::Label<ClosureBinder>) -> Self {

// SAFETY: this is safe because in the dbscheme ClosureBinder is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Expr {

_unused: ()

}

impl trap::TrapClass for Expr {

fn class_name() -> &'static str { "Expr" }

}

impl From<trap::Label<Expr>> for trap::Label<AstNode> {

fn from(value: trap::Label<Expr>) -> Self {

// SAFETY: this is safe because in the dbscheme Expr is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Expr>> for trap::Label<Element> {

fn from(value: trap::Label<Expr>) -> Self {

// SAFETY: this is safe because in the dbscheme Expr is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Expr>> for trap::Label<Locatable> {

fn from(value: trap::Label<Expr>) -> Self {

// SAFETY: this is safe because in the dbscheme Expr is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct ExternItem {

_unused: ()

}

impl trap::TrapClass for ExternItem {

fn class_name() -> &'static str { "ExternItem" }

}

impl From<trap::Label<ExternItem>> for trap::Label<AstNode> {

fn from(value: trap::Label<ExternItem>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItem is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ExternItem>> for trap::Label<Element> {

fn from(value: trap::Label<ExternItem>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ExternItem>> for trap::Label<Locatable> {

fn from(value: trap::Label<ExternItem>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItem is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct ExternItemList {

pub id: trap::TrapId<ExternItemList>,

pub attrs: Vec<trap::Label<Attr>>,

pub extern_items: Vec<trap::Label<ExternItem>>,

}

impl trap::TrapEntry for ExternItemList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("extern_item_lists", vec![id.into()]);

for (i, v) in self.attrs.into_iter().enumerate() {

out.add_tuple("extern_item_list_attrs", vec![id.into(), i.into(), v.into()]);

}

for (i, v) in self.extern_items.into_iter().enumerate() {

out.add_tuple("extern_item_list_extern_items", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for ExternItemList {

fn class_name() -> &'static str { "ExternItemList" }

}

impl From<trap::Label<ExternItemList>> for trap::Label<AstNode> {

fn from(value: trap::Label<ExternItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ExternItemList>> for trap::Label<Element> {

fn from(value: trap::Label<ExternItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ExternItemList>> for trap::Label<Locatable> {

fn from(value: trap::Label<ExternItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ExternItemList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct FieldList {

_unused: ()

}

impl trap::TrapClass for FieldList {

fn class_name() -> &'static str { "FieldList" }

}

impl From<trap::Label<FieldList>> for trap::Label<AstNode> {

fn from(value: trap::Label<FieldList>) -> Self {

// SAFETY: this is safe because in the dbscheme FieldList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<FieldList>> for trap::Label<Element> {

fn from(value: trap::Label<FieldList>) -> Self {

// SAFETY: this is safe because in the dbscheme FieldList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<FieldList>> for trap::Label<Locatable> {

fn from(value: trap::Label<FieldList>) -> Self {

// SAFETY: this is safe because in the dbscheme FieldList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct FormatArgsArg {

pub id: trap::TrapId<FormatArgsArg>,

pub expr: Option<trap::Label<Expr>>,

pub name: Option<trap::Label<Name>>,

}

impl trap::TrapEntry for FormatArgsArg {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("format_args_args", vec![id.into()]);

if let Some(v) = self.expr {

out.add_tuple("format_args_arg_exprs", vec![id.into(), v.into()]);

}

if let Some(v) = self.name {

out.add_tuple("format_args_arg_names", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for FormatArgsArg {

fn class_name() -> &'static str { "FormatArgsArg" }

}

impl From<trap::Label<FormatArgsArg>> for trap::Label<AstNode> {

fn from(value: trap::Label<FormatArgsArg>) -> Self {

// SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<FormatArgsArg>> for trap::Label<Element> {

fn from(value: trap::Label<FormatArgsArg>) -> Self {

// SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<FormatArgsArg>> for trap::Label<Locatable> {

fn from(value: trap::Label<FormatArgsArg>) -> Self {

// SAFETY: this is safe because in the dbscheme FormatArgsArg is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct GenericArg {

_unused: ()

}

impl trap::TrapClass for GenericArg {

fn class_name() -> &'static str { "GenericArg" }

}

impl From<trap::Label<GenericArg>> for trap::Label<AstNode> {

fn from(value: trap::Label<GenericArg>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArg is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericArg>> for trap::Label<Element> {

fn from(value: trap::Label<GenericArg>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericArg>> for trap::Label<Locatable> {

fn from(value: trap::Label<GenericArg>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArg is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct GenericArgList {

pub id: trap::TrapId<GenericArgList>,

pub generic_args: Vec<trap::Label<GenericArg>>,

}

impl trap::TrapEntry for GenericArgList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("generic_arg_lists", vec![id.into()]);

for (i, v) in self.generic_args.into_iter().enumerate() {

out.add_tuple("generic_arg_list_generic_args", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for GenericArgList {

fn class_name() -> &'static str { "GenericArgList" }

}

impl From<trap::Label<GenericArgList>> for trap::Label<AstNode> {

fn from(value: trap::Label<GenericArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericArgList>> for trap::Label<Element> {

fn from(value: trap::Label<GenericArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericArgList>> for trap::Label<Locatable> {

fn from(value: trap::Label<GenericArgList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericArgList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct GenericParam {

_unused: ()

}

impl trap::TrapClass for GenericParam {

fn class_name() -> &'static str { "GenericParam" }

}

impl From<trap::Label<GenericParam>> for trap::Label<AstNode> {

fn from(value: trap::Label<GenericParam>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParam is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericParam>> for trap::Label<Element> {

fn from(value: trap::Label<GenericParam>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericParam>> for trap::Label<Locatable> {

fn from(value: trap::Label<GenericParam>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParam is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct GenericParamList {

pub id: trap::TrapId<GenericParamList>,

pub generic_params: Vec<trap::Label<GenericParam>>,

}

impl trap::TrapEntry for GenericParamList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("generic_param_lists", vec![id.into()]);

for (i, v) in self.generic_params.into_iter().enumerate() {

out.add_tuple("generic_param_list_generic_params", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for GenericParamList {

fn class_name() -> &'static str { "GenericParamList" }

}

impl From<trap::Label<GenericParamList>> for trap::Label<AstNode> {

fn from(value: trap::Label<GenericParamList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericParamList>> for trap::Label<Element> {

fn from(value: trap::Label<GenericParamList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<GenericParamList>> for trap::Label<Locatable> {

fn from(value: trap::Label<GenericParamList>) -> Self {

// SAFETY: this is safe because in the dbscheme GenericParamList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct ItemList {

pub id: trap::TrapId<ItemList>,

pub attrs: Vec<trap::Label<Attr>>,

pub items: Vec<trap::Label<Item>>,

}

impl trap::TrapEntry for ItemList {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("item_lists", vec![id.into()]);

for (i, v) in self.attrs.into_iter().enumerate() {

out.add_tuple("item_list_attrs", vec![id.into(), i.into(), v.into()]);

}

for (i, v) in self.items.into_iter().enumerate() {

out.add_tuple("item_list_items", vec![id.into(), i.into(), v.into()]);

}

}

}

impl trap::TrapClass for ItemList {

fn class_name() -> &'static str { "ItemList" }

}

impl From<trap::Label<ItemList>> for trap::Label<AstNode> {

fn from(value: trap::Label<ItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ItemList is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ItemList>> for trap::Label<Element> {

fn from(value: trap::Label<ItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ItemList is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<ItemList>> for trap::Label<Locatable> {

fn from(value: trap::Label<ItemList>) -> Self {

// SAFETY: this is safe because in the dbscheme ItemList is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct Label {

pub id: trap::TrapId<Label>,

pub lifetime: Option<trap::Label<Lifetime>>,

}

impl trap::TrapEntry for Label {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("labels", vec![id.into()]);

if let Some(v) = self.lifetime {

out.add_tuple("label_lifetimes", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for Label {

fn class_name() -> &'static str { "Label" }

}

impl From<trap::Label<Label>> for trap::Label<AstNode> {

fn from(value: trap::Label<Label>) -> Self {

// SAFETY: this is safe because in the dbscheme Label is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Label>> for trap::Label<Element> {

fn from(value: trap::Label<Label>) -> Self {

// SAFETY: this is safe because in the dbscheme Label is a subclass of Element

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

impl From<trap::Label<Label>> for trap::Label<Locatable> {

fn from(value: trap::Label<Label>) -> Self {

// SAFETY: this is safe because in the dbscheme Label is a subclass of Locatable

unsafe {

Self::from_untyped(value.as_untyped())

}

}

}

#[derive(Debug)]

pub struct LetElse {

pub id: trap::TrapId<LetElse>,

pub block_expr: Option<trap::Label<BlockExpr>>,

}

impl trap::TrapEntry for LetElse {

fn extract_id(&mut self) -> trap::TrapId<Self> {

std::mem::replace(&mut self.id, trap::TrapId::Star)

}

fn emit(self, id: trap::Label<Self>, out: &mut trap::Writer) {

out.add_tuple("let_elses", vec![id.into()]);

if let Some(v) = self.block_expr {

out.add_tuple("let_else_block_exprs", vec![id.into(), v.into()]);

}

}

}

impl trap::TrapClass for LetElse {

fn class_name() -> &'static str { "LetElse" }

}

impl From<trap::Label<LetElse>> for trap::Label<AstNode> {

fn from(value: trap::Label<LetElse>) -> Self {

// SAFETY: this is safe because in the dbscheme LetElse is a subclass of AstNode

unsafe {

Self::from_untyped(value.as_untyped())

}

}