diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs
index 5871326cbad..e6f39c4147d 100644
--- a/rust/ast-generator/src/main.rs
+++ b/rust/ast-generator/src/main.rs
@@ -52,6 +52,32 @@ fn property_name(type_name: &str, field_name: &str) -> String {
     name.to_owned()
 }
 
+fn has_special_emission(type_name: &str) -> bool {
+    matches!(
+        type_name,
+        "Item"
+            | "AssocItem"
+            | "ExternItem"
+            | "Meta"
+            | "MacroCall"
+            | "Fn"
+            | "Struct"
+            | "Enum"
+            | "Union"
+            | "Trait"
+            | "Module"
+            | "Variant"
+            | "PathExpr"
+            | "RecordExpr"
+            | "PathPat"
+            | "RecordPat"
+            | "TupleStructPat"
+            | "MethodCallExpr"
+            | "PathSegment"
+            | "Const"
+    )
+}
+
 fn to_lower_snake_case(s: &str) -> String {
     let mut buf = String::with_capacity(s.len());
     let mut prev = false;
@@ -355,6 +381,7 @@ struct ExtractorEnumInfo {
     snake_case_name: String,
     ast_name: String,
     variants: Vec<EnumVariantInfo>,
+    has_special_emission: bool,
 }
 
 #[derive(Serialize, Default)]
@@ -376,6 +403,7 @@ struct ExtractorNodeInfo {
     ast_name: String,
     fields: Vec<ExtractorNodeFieldInfo>,
     has_attrs: bool,
+    has_special_emission: bool,
 }
 
 #[derive(Serialize)]
@@ -406,6 +434,7 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> Option<ExtractorEnumInfo> {
                 }
             })
             .collect(),
+        has_special_emission: has_special_emission(&node.name),
     })
 }
 
@@ -460,6 +489,7 @@ fn node_to_extractor_info(node: &AstNodeSrc) -> ExtractorNodeInfo {
         ast_name: node.name.clone(),
         fields,
         has_attrs,
+        has_special_emission: has_special_emission(&node.name),
     }
 }
 
diff --git a/rust/ast-generator/templates/extractor.mustache b/rust/ast-generator/templates/extractor.mustache
index ab1fd4b0d37..03269c26ae3 100644
--- a/rust/ast-generator/templates/extractor.mustache
+++ b/rust/ast-generator/templates/extractor.mustache
@@ -1,8 +1,7 @@
 //! Generated by `ast-generator`, do not edit by hand.
 
 use super::base::Translator;
-use super::mappings::TextValue;
-use crate::{pre_emit,post_emit};
+use super::mappings::{TextValue, HasTrapClass, Emission};
 use crate::generated;
 use crate::trap::{Label, TrapId};
 use ra_ap_syntax::ast::{
@@ -13,29 +12,23 @@ use ra_ap_syntax::ast::{
 use ra_ap_syntax::{AstNode, ast};
 
 impl Translator<'_> {
-    fn emit_else_branch(&mut self, node: &ast::ElseBranch) -> Option<Label<generated::Expr>> {
-        match node {
-            ast::ElseBranch::IfExpr(inner) => self.emit_if_expr(inner).map(Into::into),
-            ast::ElseBranch::Block(inner) => self.emit_block_expr(inner).map(Into::into),
-        }
-    }
     {{#enums}}
 
     pub(crate) fn emit_{{snake_case_name}}(&mut self, node: &ast::{{ast_name}}) -> Option<Label<generated::{{name}}>> {
-        pre_emit!({{name}}, self, node);
+        {{>pre_emission}}
         let label = match node {
             {{#variants}}
             ast::{{ast_name}}::{{variant_ast_name}}(inner) => self.emit_{{snake_case_name}}(inner).map(Into::into),
             {{/variants}}
         }?;
-        post_emit!({{name}}, self, node, label);
+        {{>post_emission}}
         Some(label)
     }
     {{/enums}}
     {{#nodes}}
 
     pub(crate) fn emit_{{snake_case_name}}(&mut self, node: &ast::{{ast_name}}) -> Option<Label<generated::{{name}}>> {
-        pre_emit!({{name}}, self, node);
+        {{>pre_emission}}
         {{#has_attrs}}
         if self.should_be_excluded(node) { return None; }
         {{/has_attrs}}
@@ -65,9 +58,15 @@ impl Translator<'_> {
             {{/fields}}
         });
         self.emit_location(label, node);
-        post_emit!({{name}}, self, node, label);
+        {{>post_emission}}
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     {{/nodes}}
 }
+{{#enums}}
+{{>trap_class_mapping}}
+{{/enums}}
+{{#nodes}}
+{{>trap_class_mapping}}
+{{/nodes}}
diff --git a/rust/ast-generator/templates/post_emission.mustache b/rust/ast-generator/templates/post_emission.mustache
new file mode 100644
index 00000000000..fb57a7802a1
--- /dev/null
+++ b/rust/ast-generator/templates/post_emission.mustache
@@ -0,0 +1,3 @@
+{{#has_special_emission}}
+self.post_emit(node, label);
+{{/has_special_emission}}
diff --git a/rust/ast-generator/templates/pre_emission.mustache b/rust/ast-generator/templates/pre_emission.mustache
new file mode 100644
index 00000000000..150529c4129
--- /dev/null
+++ b/rust/ast-generator/templates/pre_emission.mustache
@@ -0,0 +1,5 @@
+{{#has_special_emission}}
+if let Some(label) = self.pre_emit(node) {
+  return Some(label);
+}
+{{/has_special_emission}}
diff --git a/rust/ast-generator/templates/trap_class_mapping.mustache b/rust/ast-generator/templates/trap_class_mapping.mustache
new file mode 100644
index 00000000000..6d833c64067
--- /dev/null
+++ b/rust/ast-generator/templates/trap_class_mapping.mustache
@@ -0,0 +1,6 @@
+{{#has_special_emission}}
+
+impl HasTrapClass for ast::{{ast_name}} {
+    type TrapClass = generated::{{name}};
+}
+{{/has_special_emission}}
diff --git a/rust/extractor/src/translate/base.rs b/rust/extractor/src/translate/base.rs
index a71d9787e94..6c7a8ce7db1 100644
--- a/rust/extractor/src/translate/base.rs
+++ b/rust/extractor/src/translate/base.rs
@@ -1,4 +1,4 @@
-use super::mappings::{AddressableAst, AddressableHir, PathAst};
+use super::mappings::{AddressableAst, AddressableHir, Emission, PathAst};
 use crate::generated::{self};
 use crate::rust_analyzer::FileSemanticInformation;
 use crate::trap::{DiagnosticSeverity, TrapFile, TrapId};
@@ -22,121 +22,165 @@ use ra_ap_syntax::{
     ast,
 };
 
-#[macro_export]
-macro_rules! pre_emit {
-    (Item, $self:ident, $node:ident) => {
-        if let Some(label) = $self.prepare_item_expansion($node) {
-            return Some(label.into());
-        }
-    };
-    (AssocItem, $self:ident, $node:ident) => {
-        if let Some(label) = $self.prepare_item_expansion(&$node.clone().into()) {
-            return Some(label.into());
-        }
-    };
-    (ExternItem, $self:ident, $node:ident) => {
-        if let Some(label) = $self.prepare_item_expansion(&$node.clone().into()) {
-            return Some(label.into());
-        }
-    };
-    (Meta, $self:ident, $node:ident) => {
-        // rust-analyzer doesn't expand macros in this context
-        $self.macro_context_depth += 1;
-    };
-    ($($_:tt)*) => {};
+impl Emission<ast::Item> for Translator<'_> {
+    fn pre_emit(&mut self, node: &ast::Item) -> Option<Label<generated::Item>> {
+        self.prepare_item_expansion(node).map(Into::into)
+    }
+
+    fn post_emit(&mut self, node: &ast::Item, label: Label<generated::Item>) {
+        self.emit_item_expansion(node, label);
+    }
 }
 
-// TODO: remove the mannually written Label conversions. These can be auto-generated by
-// changing the base class of AssocItem from AstNode to Item
-impl From<crate::trap::Label<generated::AssocItem>> for crate::trap::Label<generated::Item> {
-    fn from(value: crate::trap::Label<generated::AssocItem>) -> Self {
+impl Emission<ast::AssocItem> for Translator<'_> {
+    fn pre_emit(&mut self, node: &ast::AssocItem) -> Option<Label<generated::AssocItem>> {
+        self.prepare_item_expansion(&node.clone().into())
+            .map(Into::into)
+    }
+
+    fn post_emit(&mut self, node: &ast::AssocItem, label: Label<generated::AssocItem>) {
+        self.emit_item_expansion(&node.clone().into(), label.into());
+    }
+}
+
+impl Emission<ast::ExternItem> for Translator<'_> {
+    fn pre_emit(&mut self, node: &ast::ExternItem) -> Option<Label<generated::ExternItem>> {
+        self.prepare_item_expansion(&node.clone().into())
+            .map(Into::into)
+    }
+
+    fn post_emit(&mut self, node: &ast::ExternItem, label: Label<generated::ExternItem>) {
+        self.emit_item_expansion(&node.clone().into(), label.into());
+    }
+}
+
+impl Emission<ast::Meta> for Translator<'_> {
+    fn pre_emit(&mut self, _node: &ast::Meta) -> Option<Label<generated::Meta>> {
+        self.macro_context_depth += 1;
+        None
+    }
+
+    fn post_emit(&mut self, _node: &ast::Meta, _label: Label<generated::Meta>) {
+        self.macro_context_depth -= 1;
+    }
+}
+
+impl Emission<ast::Fn> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Fn, label: Label<generated::Function>) {
+        self.emit_function_has_implementation(node, label);
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Struct> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Struct, label: Label<generated::Struct>) {
+        self.emit_derive_expansion(node, label);
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Enum> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Enum, label: Label<generated::Enum>) {
+        self.emit_derive_expansion(node, label);
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Union> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Union, label: Label<generated::Union>) {
+        self.emit_derive_expansion(node, label);
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Trait> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Trait, label: Label<generated::Trait>) {
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Module> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Module, label: Label<generated::Module>) {
+        self.extract_canonical_origin(node, label.into());
+    }
+}
+
+impl Emission<ast::Variant> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Variant, label: Label<generated::Variant>) {
+        self.extract_canonical_origin_of_enum_variant(node, label);
+    }
+}
+
+impl Emission<ast::PathExpr> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::PathExpr, label: Label<generated::PathExpr>) {
+        self.extract_path_canonical_destination(node, label.into());
+    }
+}
+
+impl Emission<ast::RecordExpr> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::RecordExpr, label: Label<generated::StructExpr>) {
+        self.extract_path_canonical_destination(node, label.into());
+    }
+}
+
+impl Emission<ast::PathPat> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::PathPat, label: Label<generated::PathPat>) {
+        self.extract_path_canonical_destination(node, label.into());
+    }
+}
+
+impl Emission<ast::RecordPat> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::RecordPat, label: Label<generated::StructPat>) {
+        self.extract_path_canonical_destination(node, label.into());
+    }
+}
+
+impl Emission<ast::TupleStructPat> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::TupleStructPat, label: Label<generated::TupleStructPat>) {
+        self.extract_path_canonical_destination(node, label.into());
+    }
+}
+
+impl Emission<ast::MethodCallExpr> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::MethodCallExpr, label: Label<generated::MethodCallExpr>) {
+        self.extract_method_canonical_destination(node, label);
+    }
+}
+
+impl Emission<ast::PathSegment> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::PathSegment, label: Label<generated::PathSegment>) {
+        self.extract_types_from_path_segment(node, label);
+    }
+}
+
+impl Emission<ast::Const> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::Const, label: Label<generated::Const>) {
+        self.emit_const_has_implementation(node, label);
+    }
+}
+
+impl Emission<ast::MacroCall> for Translator<'_> {
+    fn post_emit(&mut self, node: &ast::MacroCall, label: Label<generated::MacroCall>) {
+        self.extract_macro_call_expanded(node, label);
+    }
+}
+// TODO: remove the manually written Label conversions. These can be auto-generated by
+// ch
+// anging the base class of AssocItem from AstNode to Item
+impl From<Label<generated::AssocItem>> for Label<generated::Item> {
+    fn from(value: Label<generated::AssocItem>) -> Self {
         // SAFETY: this is safe because every concrete instance of `@assoc_item` is also an instance of `@item`
         unsafe { Self::from_untyped(value.as_untyped()) }
     }
 }
-// TODO: remove the mannually written Label conversions. These can be auto-generated by
+// TODO: remove the manually written Label conversions. These can be auto-generated by
 // changing the base class of ExternItem from AstNode to Item
-impl From<crate::trap::Label<generated::ExternItem>> for crate::trap::Label<generated::Item> {
-    fn from(value: crate::trap::Label<generated::ExternItem>) -> Self {
+impl From<Label<generated::ExternItem>> for Label<generated::Item> {
+    fn from(value: Label<generated::ExternItem>) -> Self {
         // SAFETY: this is safe because every concrete instance of `@extern_item` is also an instance of `@item`
         unsafe { Self::from_untyped(value.as_untyped()) }
     }
 }
-#[macro_export]
-macro_rules! post_emit {
-    (Meta, $self:ident, $node:ident, $label:ident) => {
-        $self.macro_context_depth -= 1;
-    };
-    (MacroCall, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_macro_call_expanded($node, $label);
-    };
-    (Function, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_function_has_implementation($node, $label);
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Trait, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Struct, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_derive_expansion($node, $label);
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Enum, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_derive_expansion($node, $label);
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Union, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_derive_expansion($node, $label);
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Module, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin($node, $label.into());
-    };
-    (Variant, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_origin_of_enum_variant($node, $label);
-    };
-    (Item, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_item_expansion($node, $label);
-    };
-    (AssocItem, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_item_expansion(
-            &$node.clone().into(),
-            From::<Label<generated::AssocItem>>::from($label),
-        );
-    };
-    (ExternItem, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_item_expansion(
-            &$node.clone().into(),
-            From::<Label<generated::ExternItem>>::from($label),
-        );
-    };
-    // TODO canonical origin of other items
-    (PathExpr, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_path_canonical_destination($node, $label.into());
-    };
-    (StructExpr, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_path_canonical_destination($node, $label.into());
-    };
-    (PathPat, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_path_canonical_destination($node, $label.into());
-    };
-    (StructPat, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_path_canonical_destination($node, $label.into());
-    };
-    (TupleStructPat, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_path_canonical_destination($node, $label.into());
-    };
-    (MethodCallExpr, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_method_canonical_destination($node, $label);
-    };
-    (PathSegment, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_types_from_path_segment($node, $label.into());
-    };
-    (Const, $self:ident, $node:ident, $label:ident) => {
-        $self.emit_const_has_implementation($node, $label);
-    };
-    ($($_:tt)*) => {};
-}
 
 // see https://github.com/tokio-rs/tracing/issues/2730
 macro_rules! dispatch_to_tracing {
@@ -497,6 +541,17 @@ impl<'a> Translator<'a> {
             );
         }
     }
+
+    pub(crate) fn emit_else_branch(
+        &mut self,
+        node: &ast::ElseBranch,
+    ) -> Option<Label<generated::Expr>> {
+        match node {
+            ast::ElseBranch::IfExpr(inner) => self.emit_if_expr(inner).map(Into::into),
+            ast::ElseBranch::Block(inner) => self.emit_block_expr(inner).map(Into::into),
+        }
+    }
+
     fn canonical_path_from_type(&self, ty: Type) -> Option<String> {
         let sema = self.semantics.as_ref().unwrap();
         // rust-analyzer doesn't provide a type enum directly
diff --git a/rust/extractor/src/translate/generated.rs b/rust/extractor/src/translate/generated.rs
index 39efe763a3b..787ce71bf2a 100644
--- a/rust/extractor/src/translate/generated.rs
+++ b/rust/extractor/src/translate/generated.rs
@@ -1,9 +1,8 @@
 //! Generated by `ast-generator`, do not edit by hand.
 use super::base::Translator;
-use super::mappings::TextValue;
+use super::mappings::{Emission, HasTrapClass, TextValue};
 use crate::generated;
 use crate::trap::{Label, TrapId};
-use crate::{post_emit, pre_emit};
 use ra_ap_syntax::ast::{
     HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasModuleItem, HasName,
     HasTypeBounds, HasVisibility, RangeItem,
@@ -11,17 +10,10 @@ use ra_ap_syntax::ast::{
 #[rustfmt::skip]
 use ra_ap_syntax::{AstNode, ast};
 impl Translator<'_> {
-    fn emit_else_branch(&mut self, node: &ast::ElseBranch) -> Option<Label<generated::Expr>> {
-        match node {
-            ast::ElseBranch::IfExpr(inner) => self.emit_if_expr(inner).map(Into::into),
-            ast::ElseBranch::Block(inner) => self.emit_block_expr(inner).map(Into::into),
-        }
-    }
     pub(crate) fn emit_asm_operand(
         &mut self,
         node: &ast::AsmOperand,
     ) -> Option<Label<generated::AsmOperand>> {
-        pre_emit!(AsmOperand, self, node);
         let label = match node {
             ast::AsmOperand::AsmConst(inner) => self.emit_asm_const(inner).map(Into::into),
             ast::AsmOperand::AsmLabel(inner) => self.emit_asm_label(inner).map(Into::into),
@@ -30,14 +22,12 @@ impl Translator<'_> {
             }
             ast::AsmOperand::AsmSym(inner) => self.emit_asm_sym(inner).map(Into::into),
         }?;
-        post_emit!(AsmOperand, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_asm_piece(
         &mut self,
         node: &ast::AsmPiece,
     ) -> Option<Label<generated::AsmPiece>> {
-        pre_emit!(AsmPiece, self, node);
         let label = match node {
             ast::AsmPiece::AsmClobberAbi(inner) => self.emit_asm_clobber_abi(inner).map(Into::into),
             ast::AsmPiece::AsmOperandNamed(inner) => {
@@ -45,25 +35,25 @@ impl Translator<'_> {
             }
             ast::AsmPiece::AsmOptions(inner) => self.emit_asm_options(inner).map(Into::into),
         }?;
-        post_emit!(AsmPiece, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_assoc_item(
         &mut self,
         node: &ast::AssocItem,
     ) -> Option<Label<generated::AssocItem>> {
-        pre_emit!(AssocItem, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let label = match node {
             ast::AssocItem::Const(inner) => self.emit_const(inner).map(Into::into),
             ast::AssocItem::Fn(inner) => self.emit_fn(inner).map(Into::into),
             ast::AssocItem::MacroCall(inner) => self.emit_macro_call(inner).map(Into::into),
             ast::AssocItem::TypeAlias(inner) => self.emit_type_alias(inner).map(Into::into),
         }?;
-        post_emit!(AssocItem, self, node, label);
+        self.post_emit(node, label);
         Some(label)
     }
     pub(crate) fn emit_expr(&mut self, node: &ast::Expr) -> Option<Label<generated::Expr>> {
-        pre_emit!(Expr, self, node);
         let label = match node {
             ast::Expr::ArrayExpr(inner) => self.emit_array_expr(inner).map(Into::into),
             ast::Expr::AsmExpr(inner) => self.emit_asm_expr(inner).map(Into::into),
@@ -102,28 +92,28 @@ impl Translator<'_> {
             ast::Expr::YeetExpr(inner) => self.emit_yeet_expr(inner).map(Into::into),
             ast::Expr::YieldExpr(inner) => self.emit_yield_expr(inner).map(Into::into),
         }?;
-        post_emit!(Expr, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_extern_item(
         &mut self,
         node: &ast::ExternItem,
     ) -> Option<Label<generated::ExternItem>> {
-        pre_emit!(ExternItem, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let label = match node {
             ast::ExternItem::Fn(inner) => self.emit_fn(inner).map(Into::into),
             ast::ExternItem::MacroCall(inner) => self.emit_macro_call(inner).map(Into::into),
             ast::ExternItem::Static(inner) => self.emit_static(inner).map(Into::into),
             ast::ExternItem::TypeAlias(inner) => self.emit_type_alias(inner).map(Into::into),
         }?;
-        post_emit!(ExternItem, self, node, label);
+        self.post_emit(node, label);
         Some(label)
     }
     pub(crate) fn emit_field_list(
         &mut self,
         node: &ast::FieldList,
     ) -> Option<Label<generated::FieldList>> {
-        pre_emit!(FieldList, self, node);
         let label = match node {
             ast::FieldList::RecordFieldList(inner) => {
                 self.emit_record_field_list(inner).map(Into::into)
@@ -132,28 +122,24 @@ impl Translator<'_> {
                 self.emit_tuple_field_list(inner).map(Into::into)
             }
         }?;
-        post_emit!(FieldList, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_generic_arg(
         &mut self,
         node: &ast::GenericArg,
     ) -> Option<Label<generated::GenericArg>> {
-        pre_emit!(GenericArg, self, node);
         let label = match node {
             ast::GenericArg::AssocTypeArg(inner) => self.emit_assoc_type_arg(inner).map(Into::into),
             ast::GenericArg::ConstArg(inner) => self.emit_const_arg(inner).map(Into::into),
             ast::GenericArg::LifetimeArg(inner) => self.emit_lifetime_arg(inner).map(Into::into),
             ast::GenericArg::TypeArg(inner) => self.emit_type_arg(inner).map(Into::into),
         }?;
-        post_emit!(GenericArg, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_generic_param(
         &mut self,
         node: &ast::GenericParam,
     ) -> Option<Label<generated::GenericParam>> {
-        pre_emit!(GenericParam, self, node);
         let label = match node {
             ast::GenericParam::ConstParam(inner) => self.emit_const_param(inner).map(Into::into),
             ast::GenericParam::LifetimeParam(inner) => {
@@ -161,11 +147,9 @@ impl Translator<'_> {
             }
             ast::GenericParam::TypeParam(inner) => self.emit_type_param(inner).map(Into::into),
         }?;
-        post_emit!(GenericParam, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_pat(&mut self, node: &ast::Pat) -> Option<Label<generated::Pat>> {
-        pre_emit!(Pat, self, node);
         let label = match node {
             ast::Pat::BoxPat(inner) => self.emit_box_pat(inner).map(Into::into),
             ast::Pat::ConstBlockPat(inner) => self.emit_const_block_pat(inner).map(Into::into),
@@ -184,21 +168,17 @@ impl Translator<'_> {
             ast::Pat::TupleStructPat(inner) => self.emit_tuple_struct_pat(inner).map(Into::into),
             ast::Pat::WildcardPat(inner) => self.emit_wildcard_pat(inner).map(Into::into),
         }?;
-        post_emit!(Pat, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_stmt(&mut self, node: &ast::Stmt) -> Option<Label<generated::Stmt>> {
-        pre_emit!(Stmt, self, node);
         let label = match node {
             ast::Stmt::ExprStmt(inner) => self.emit_expr_stmt(inner).map(Into::into),
             ast::Stmt::Item(inner) => self.emit_item(inner).map(Into::into),
             ast::Stmt::LetStmt(inner) => self.emit_let_stmt(inner).map(Into::into),
         }?;
-        post_emit!(Stmt, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_type(&mut self, node: &ast::Type) -> Option<Label<generated::TypeRepr>> {
-        pre_emit!(TypeRepr, self, node);
         let label = match node {
             ast::Type::ArrayType(inner) => self.emit_array_type(inner).map(Into::into),
             ast::Type::DynTraitType(inner) => self.emit_dyn_trait_type(inner).map(Into::into),
@@ -215,23 +195,22 @@ impl Translator<'_> {
             ast::Type::SliceType(inner) => self.emit_slice_type(inner).map(Into::into),
             ast::Type::TupleType(inner) => self.emit_tuple_type(inner).map(Into::into),
         }?;
-        post_emit!(TypeRepr, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_use_bound_generic_arg(
         &mut self,
         node: &ast::UseBoundGenericArg,
     ) -> Option<Label<generated::UseBoundGenericArg>> {
-        pre_emit!(UseBoundGenericArg, self, node);
         let label = match node {
             ast::UseBoundGenericArg::Lifetime(inner) => self.emit_lifetime(inner).map(Into::into),
             ast::UseBoundGenericArg::NameRef(inner) => self.emit_name_ref(inner).map(Into::into),
         }?;
-        post_emit!(UseBoundGenericArg, self, node, label);
         Some(label)
     }
     pub(crate) fn emit_item(&mut self, node: &ast::Item) -> Option<Label<generated::Item>> {
-        pre_emit!(Item, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let label = match node {
             ast::Item::Const(inner) => self.emit_const(inner).map(Into::into),
             ast::Item::Enum(inner) => self.emit_enum(inner).map(Into::into),
@@ -251,18 +230,16 @@ impl Translator<'_> {
             ast::Item::Union(inner) => self.emit_union(inner).map(Into::into),
             ast::Item::Use(inner) => self.emit_use(inner).map(Into::into),
         }?;
-        post_emit!(Item, self, node, label);
+        self.post_emit(node, label);
         Some(label)
     }
     pub(crate) fn emit_abi(&mut self, node: &ast::Abi) -> Option<Label<generated::Abi>> {
-        pre_emit!(Abi, self, node);
         let abi_string = node.try_get_text();
         let label = self.trap.emit(generated::Abi {
             id: TrapId::Star,
             abi_string,
         });
         self.emit_location(label, node);
-        post_emit!(Abi, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -270,14 +247,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ArgList,
     ) -> Option<Label<generated::ArgList>> {
-        pre_emit!(ArgList, self, node);
         let args = node.args().filter_map(|x| self.emit_expr(&x)).collect();
         let label = self.trap.emit(generated::ArgList {
             id: TrapId::Star,
             args,
         });
         self.emit_location(label, node);
-        post_emit!(ArgList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -285,7 +260,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ArrayExpr,
     ) -> Option<Label<generated::ArrayExprInternal>> {
-        pre_emit!(ArrayExprInternal, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -299,7 +273,6 @@ impl Translator<'_> {
             is_semicolon,
         });
         self.emit_location(label, node);
-        post_emit!(ArrayExprInternal, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -307,7 +280,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ArrayType,
     ) -> Option<Label<generated::ArrayTypeRepr>> {
-        pre_emit!(ArrayTypeRepr, self, node);
         let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x));
         let element_type_repr = node.ty().and_then(|x| self.emit_type(&x));
         let label = self.trap.emit(generated::ArrayTypeRepr {
@@ -316,7 +288,6 @@ impl Translator<'_> {
             element_type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(ArrayTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -324,12 +295,10 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmClobberAbi,
     ) -> Option<Label<generated::AsmClobberAbi>> {
-        pre_emit!(AsmClobberAbi, self, node);
         let label = self
             .trap
             .emit(generated::AsmClobberAbi { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(AsmClobberAbi, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -337,7 +306,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmConst,
     ) -> Option<Label<generated::AsmConst>> {
-        pre_emit!(AsmConst, self, node);
         let expr = node.expr().and_then(|x| self.emit_expr(&x));
         let is_const = node.const_token().is_some();
         let label = self.trap.emit(generated::AsmConst {
@@ -346,7 +314,6 @@ impl Translator<'_> {
             is_const,
         });
         self.emit_location(label, node);
-        post_emit!(AsmConst, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -354,10 +321,8 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmDirSpec,
     ) -> Option<Label<generated::AsmDirSpec>> {
-        pre_emit!(AsmDirSpec, self, node);
         let label = self.trap.emit(generated::AsmDirSpec { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(AsmDirSpec, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -365,7 +330,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmExpr,
     ) -> Option<Label<generated::AsmExpr>> {
-        pre_emit!(AsmExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -382,7 +346,6 @@ impl Translator<'_> {
             template,
         });
         self.emit_location(label, node);
-        post_emit!(AsmExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -390,14 +353,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmLabel,
     ) -> Option<Label<generated::AsmLabel>> {
-        pre_emit!(AsmLabel, self, node);
         let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x));
         let label = self.trap.emit(generated::AsmLabel {
             id: TrapId::Star,
             block_expr,
         });
         self.emit_location(label, node);
-        post_emit!(AsmLabel, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -405,7 +366,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmOperandExpr,
     ) -> Option<Label<generated::AsmOperandExpr>> {
-        pre_emit!(AsmOperandExpr, self, node);
         let in_expr = node.in_expr().and_then(|x| self.emit_expr(&x));
         let out_expr = node.out_expr().and_then(|x| self.emit_expr(&x));
         let label = self.trap.emit(generated::AsmOperandExpr {
@@ -414,7 +374,6 @@ impl Translator<'_> {
             out_expr,
         });
         self.emit_location(label, node);
-        post_emit!(AsmOperandExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -422,7 +381,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmOperandNamed,
     ) -> Option<Label<generated::AsmOperandNamed>> {
-        pre_emit!(AsmOperandNamed, self, node);
         let asm_operand = node.asm_operand().and_then(|x| self.emit_asm_operand(&x));
         let name = node.name().and_then(|x| self.emit_name(&x));
         let label = self.trap.emit(generated::AsmOperandNamed {
@@ -431,7 +389,6 @@ impl Translator<'_> {
             name,
         });
         self.emit_location(label, node);
-        post_emit!(AsmOperandNamed, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -439,14 +396,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmOption,
     ) -> Option<Label<generated::AsmOption>> {
-        pre_emit!(AsmOption, self, node);
         let is_raw = node.raw_token().is_some();
         let label = self.trap.emit(generated::AsmOption {
             id: TrapId::Star,
             is_raw,
         });
         self.emit_location(label, node);
-        post_emit!(AsmOption, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -454,7 +409,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmOptions,
     ) -> Option<Label<generated::AsmOptionsList>> {
-        pre_emit!(AsmOptionsList, self, node);
         let asm_options = node
             .asm_options()
             .filter_map(|x| self.emit_asm_option(&x))
@@ -464,7 +418,6 @@ impl Translator<'_> {
             asm_options,
         });
         self.emit_location(label, node);
-        post_emit!(AsmOptionsList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -472,7 +425,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmRegOperand,
     ) -> Option<Label<generated::AsmRegOperand>> {
-        pre_emit!(AsmRegOperand, self, node);
         let asm_dir_spec = node.asm_dir_spec().and_then(|x| self.emit_asm_dir_spec(&x));
         let asm_operand_expr = node
             .asm_operand_expr()
@@ -485,7 +437,6 @@ impl Translator<'_> {
             asm_reg_spec,
         });
         self.emit_location(label, node);
-        post_emit!(AsmRegOperand, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -493,26 +444,22 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AsmRegSpec,
     ) -> Option<Label<generated::AsmRegSpec>> {
-        pre_emit!(AsmRegSpec, self, node);
         let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x));
         let label = self.trap.emit(generated::AsmRegSpec {
             id: TrapId::Star,
             identifier,
         });
         self.emit_location(label, node);
-        post_emit!(AsmRegSpec, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_asm_sym(&mut self, node: &ast::AsmSym) -> Option<Label<generated::AsmSym>> {
-        pre_emit!(AsmSym, self, node);
         let path = node.path().and_then(|x| self.emit_path(&x));
         let label = self.trap.emit(generated::AsmSym {
             id: TrapId::Star,
             path,
         });
         self.emit_location(label, node);
-        post_emit!(AsmSym, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -520,7 +467,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AssocItemList,
     ) -> Option<Label<generated::AssocItemList>> {
-        pre_emit!(AssocItemList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -535,7 +481,6 @@ impl Translator<'_> {
             attrs,
         });
         self.emit_location(label, node);
-        post_emit!(AssocItemList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -543,7 +488,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AssocTypeArg,
     ) -> Option<Label<generated::AssocTypeArg>> {
-        pre_emit!(AssocTypeArg, self, node);
         let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x));
         let generic_arg_list = node
             .generic_arg_list()
@@ -570,19 +514,16 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(AssocTypeArg, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_attr(&mut self, node: &ast::Attr) -> Option<Label<generated::Attr>> {
-        pre_emit!(Attr, self, node);
         let meta = node.meta().and_then(|x| self.emit_meta(&x));
         let label = self.trap.emit(generated::Attr {
             id: TrapId::Star,
             meta,
         });
         self.emit_location(label, node);
-        post_emit!(Attr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -590,7 +531,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::AwaitExpr,
     ) -> Option<Label<generated::AwaitExpr>> {
-        pre_emit!(AwaitExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -602,7 +542,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(AwaitExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -610,7 +549,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::BecomeExpr,
     ) -> Option<Label<generated::BecomeExpr>> {
-        pre_emit!(BecomeExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -622,7 +560,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(BecomeExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -630,7 +567,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::BinExpr,
     ) -> Option<Label<generated::BinaryExpr>> {
-        pre_emit!(BinaryExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -646,7 +582,6 @@ impl Translator<'_> {
             rhs,
         });
         self.emit_location(label, node);
-        post_emit!(BinaryExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -654,7 +589,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::BlockExpr,
     ) -> Option<Label<generated::BlockExpr>> {
-        pre_emit!(BlockExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -680,19 +614,16 @@ impl Translator<'_> {
             stmt_list,
         });
         self.emit_location(label, node);
-        post_emit!(BlockExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_box_pat(&mut self, node: &ast::BoxPat) -> Option<Label<generated::BoxPat>> {
-        pre_emit!(BoxPat, self, node);
         let pat = node.pat().and_then(|x| self.emit_pat(&x));
         let label = self.trap.emit(generated::BoxPat {
             id: TrapId::Star,
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(BoxPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -700,7 +631,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::BreakExpr,
     ) -> Option<Label<generated::BreakExpr>> {
-        pre_emit!(BreakExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -714,7 +644,6 @@ impl Translator<'_> {
             lifetime,
         });
         self.emit_location(label, node);
-        post_emit!(BreakExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -722,7 +651,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::CallExpr,
     ) -> Option<Label<generated::CallExpr>> {
-        pre_emit!(CallExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -736,7 +664,6 @@ impl Translator<'_> {
             function,
         });
         self.emit_location(label, node);
-        post_emit!(CallExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -744,7 +671,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::CastExpr,
     ) -> Option<Label<generated::CastExpr>> {
-        pre_emit!(CastExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -758,7 +684,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(CastExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -766,7 +691,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ClosureBinder,
     ) -> Option<Label<generated::ClosureBinder>> {
-        pre_emit!(ClosureBinder, self, node);
         let generic_param_list = node
             .generic_param_list()
             .and_then(|x| self.emit_generic_param_list(&x));
@@ -775,7 +699,6 @@ impl Translator<'_> {
             generic_param_list,
         });
         self.emit_location(label, node);
-        post_emit!(ClosureBinder, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -783,7 +706,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ClosureExpr,
     ) -> Option<Label<generated::ClosureExpr>> {
-        pre_emit!(ClosureExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -813,12 +735,13 @@ impl Translator<'_> {
             ret_type,
         });
         self.emit_location(label, node);
-        post_emit!(ClosureExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_const(&mut self, node: &ast::Const) -> Option<Label<generated::Const>> {
-        pre_emit!(Const, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -850,7 +773,7 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Const, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -858,14 +781,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ConstArg,
     ) -> Option<Label<generated::ConstArg>> {
-        pre_emit!(ConstArg, self, node);
         let expr = node.expr().and_then(|x| self.emit_expr(&x));
         let label = self.trap.emit(generated::ConstArg {
             id: TrapId::Star,
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(ConstArg, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -873,7 +794,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ConstBlockPat,
     ) -> Option<Label<generated::ConstBlockPat>> {
-        pre_emit!(ConstBlockPat, self, node);
         let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x));
         let is_const = node.const_token().is_some();
         let label = self.trap.emit(generated::ConstBlockPat {
@@ -882,7 +802,6 @@ impl Translator<'_> {
             is_const,
         });
         self.emit_location(label, node);
-        post_emit!(ConstBlockPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -890,7 +809,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ConstParam,
     ) -> Option<Label<generated::ConstParam>> {
-        pre_emit!(ConstParam, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -908,7 +826,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(ConstParam, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -916,7 +833,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ContinueExpr,
     ) -> Option<Label<generated::ContinueExpr>> {
-        pre_emit!(ContinueExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -928,7 +844,6 @@ impl Translator<'_> {
             lifetime,
         });
         self.emit_location(label, node);
-        post_emit!(ContinueExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -936,7 +851,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::DynTraitType,
     ) -> Option<Label<generated::DynTraitTypeRepr>> {
-        pre_emit!(DynTraitTypeRepr, self, node);
         let type_bound_list = node
             .type_bound_list()
             .and_then(|x| self.emit_type_bound_list(&x));
@@ -945,12 +859,13 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(DynTraitTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_enum(&mut self, node: &ast::Enum) -> Option<Label<generated::Enum>> {
-        pre_emit!(Enum, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -972,7 +887,7 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Enum, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -980,14 +895,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ExprStmt,
     ) -> Option<Label<generated::ExprStmt>> {
-        pre_emit!(ExprStmt, self, node);
         let expr = node.expr().and_then(|x| self.emit_expr(&x));
         let label = self.trap.emit(generated::ExprStmt {
             id: TrapId::Star,
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(ExprStmt, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -995,7 +908,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ExternBlock,
     ) -> Option<Label<generated::ExternBlock>> {
-        pre_emit!(ExternBlock, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1013,7 +925,6 @@ impl Translator<'_> {
             is_unsafe,
         });
         self.emit_location(label, node);
-        post_emit!(ExternBlock, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1021,7 +932,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ExternCrate,
     ) -> Option<Label<generated::ExternCrate>> {
-        pre_emit!(ExternCrate, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1037,7 +947,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(ExternCrate, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1045,7 +954,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ExternItemList,
     ) -> Option<Label<generated::ExternItemList>> {
-        pre_emit!(ExternItemList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1060,7 +968,6 @@ impl Translator<'_> {
             extern_items,
         });
         self.emit_location(label, node);
-        post_emit!(ExternItemList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1068,7 +975,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::FieldExpr,
     ) -> Option<Label<generated::FieldExpr>> {
-        pre_emit!(FieldExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1082,12 +988,13 @@ impl Translator<'_> {
             identifier,
         });
         self.emit_location(label, node);
-        post_emit!(FieldExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_fn(&mut self, node: &ast::Fn) -> Option<Label<generated::Function>> {
-        pre_emit!(Function, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1129,7 +1036,7 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Function, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1137,7 +1044,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::FnPtrType,
     ) -> Option<Label<generated::FnPtrTypeRepr>> {
-        pre_emit!(FnPtrTypeRepr, self, node);
         let abi = node.abi().and_then(|x| self.emit_abi(&x));
         let is_async = node.async_token().is_some();
         let is_const = node.const_token().is_some();
@@ -1154,7 +1060,6 @@ impl Translator<'_> {
             ret_type,
         });
         self.emit_location(label, node);
-        post_emit!(FnPtrTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1162,7 +1067,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ForExpr,
     ) -> Option<Label<generated::ForExpr>> {
-        pre_emit!(ForExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1180,7 +1084,6 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(ForExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1188,7 +1091,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ForType,
     ) -> Option<Label<generated::ForTypeRepr>> {
-        pre_emit!(ForTypeRepr, self, node);
         let generic_param_list = node
             .generic_param_list()
             .and_then(|x| self.emit_generic_param_list(&x));
@@ -1199,7 +1101,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(ForTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1207,7 +1108,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::FormatArgsArg,
     ) -> Option<Label<generated::FormatArgsArg>> {
-        pre_emit!(FormatArgsArg, self, node);
         let expr = node.expr().and_then(|x| self.emit_expr(&x));
         let name = node.name().and_then(|x| self.emit_name(&x));
         let label = self.trap.emit(generated::FormatArgsArg {
@@ -1216,7 +1116,6 @@ impl Translator<'_> {
             name,
         });
         self.emit_location(label, node);
-        post_emit!(FormatArgsArg, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1224,7 +1123,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::FormatArgsExpr,
     ) -> Option<Label<generated::FormatArgsExpr>> {
-        pre_emit!(FormatArgsExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1241,7 +1139,6 @@ impl Translator<'_> {
             template,
         });
         self.emit_location(label, node);
-        post_emit!(FormatArgsExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1249,7 +1146,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::GenericArgList,
     ) -> Option<Label<generated::GenericArgList>> {
-        pre_emit!(GenericArgList, self, node);
         let generic_args = node
             .generic_args()
             .filter_map(|x| self.emit_generic_arg(&x))
@@ -1259,7 +1155,6 @@ impl Translator<'_> {
             generic_args,
         });
         self.emit_location(label, node);
-        post_emit!(GenericArgList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1267,7 +1162,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::GenericParamList,
     ) -> Option<Label<generated::GenericParamList>> {
-        pre_emit!(GenericParamList, self, node);
         let generic_params = node
             .generic_params()
             .filter_map(|x| self.emit_generic_param(&x))
@@ -1277,7 +1171,6 @@ impl Translator<'_> {
             generic_params,
         });
         self.emit_location(label, node);
-        post_emit!(GenericParamList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1285,7 +1178,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::IdentPat,
     ) -> Option<Label<generated::IdentPat>> {
-        pre_emit!(IdentPat, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1303,12 +1195,10 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(IdentPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_if_expr(&mut self, node: &ast::IfExpr) -> Option<Label<generated::IfExpr>> {
-        pre_emit!(IfExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1324,12 +1214,10 @@ impl Translator<'_> {
             then,
         });
         self.emit_location(label, node);
-        post_emit!(IfExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_impl(&mut self, node: &ast::Impl) -> Option<Label<generated::Impl>> {
-        pre_emit!(Impl, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1361,7 +1249,6 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Impl, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1369,7 +1256,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ImplTraitType,
     ) -> Option<Label<generated::ImplTraitTypeRepr>> {
-        pre_emit!(ImplTraitTypeRepr, self, node);
         let type_bound_list = node
             .type_bound_list()
             .and_then(|x| self.emit_type_bound_list(&x));
@@ -1378,7 +1264,6 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(ImplTraitTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1386,7 +1271,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::IndexExpr,
     ) -> Option<Label<generated::IndexExpr>> {
-        pre_emit!(IndexExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1400,7 +1284,6 @@ impl Translator<'_> {
             index,
         });
         self.emit_location(label, node);
-        post_emit!(IndexExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1408,12 +1291,10 @@ impl Translator<'_> {
         &mut self,
         node: &ast::InferType,
     ) -> Option<Label<generated::InferTypeRepr>> {
-        pre_emit!(InferTypeRepr, self, node);
         let label = self
             .trap
             .emit(generated::InferTypeRepr { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(InferTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1421,7 +1302,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ItemList,
     ) -> Option<Label<generated::ItemList>> {
-        pre_emit!(ItemList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1433,19 +1313,16 @@ impl Translator<'_> {
             items,
         });
         self.emit_location(label, node);
-        post_emit!(ItemList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_label(&mut self, node: &ast::Label) -> Option<Label<generated::Label>> {
-        pre_emit!(Label, self, node);
         let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x));
         let label = self.trap.emit(generated::Label {
             id: TrapId::Star,
             lifetime,
         });
         self.emit_location(label, node);
-        post_emit!(Label, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1453,14 +1330,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LetElse,
     ) -> Option<Label<generated::LetElse>> {
-        pre_emit!(LetElse, self, node);
         let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x));
         let label = self.trap.emit(generated::LetElse {
             id: TrapId::Star,
             block_expr,
         });
         self.emit_location(label, node);
-        post_emit!(LetElse, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1468,7 +1343,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LetExpr,
     ) -> Option<Label<generated::LetExpr>> {
-        pre_emit!(LetExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1482,7 +1356,6 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(LetExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1490,7 +1363,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LetStmt,
     ) -> Option<Label<generated::LetStmt>> {
-        pre_emit!(LetStmt, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1508,7 +1380,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(LetStmt, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1516,14 +1387,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::Lifetime,
     ) -> Option<Label<generated::Lifetime>> {
-        pre_emit!(Lifetime, self, node);
         let text = node.try_get_text();
         let label = self.trap.emit(generated::Lifetime {
             id: TrapId::Star,
             text,
         });
         self.emit_location(label, node);
-        post_emit!(Lifetime, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1531,14 +1400,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LifetimeArg,
     ) -> Option<Label<generated::LifetimeArg>> {
-        pre_emit!(LifetimeArg, self, node);
         let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x));
         let label = self.trap.emit(generated::LifetimeArg {
             id: TrapId::Star,
             lifetime,
         });
         self.emit_location(label, node);
-        post_emit!(LifetimeArg, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1546,7 +1413,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LifetimeParam,
     ) -> Option<Label<generated::LifetimeParam>> {
-        pre_emit!(LifetimeParam, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1562,7 +1428,6 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(LifetimeParam, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1570,7 +1435,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::Literal,
     ) -> Option<Label<generated::LiteralExpr>> {
-        pre_emit!(LiteralExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1582,7 +1446,6 @@ impl Translator<'_> {
             text_value,
         });
         self.emit_location(label, node);
-        post_emit!(LiteralExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1590,14 +1453,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LiteralPat,
     ) -> Option<Label<generated::LiteralPat>> {
-        pre_emit!(LiteralPat, self, node);
         let literal = node.literal().and_then(|x| self.emit_literal(&x));
         let label = self.trap.emit(generated::LiteralPat {
             id: TrapId::Star,
             literal,
         });
         self.emit_location(label, node);
-        post_emit!(LiteralPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1605,7 +1466,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::LoopExpr,
     ) -> Option<Label<generated::LoopExpr>> {
-        pre_emit!(LoopExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1619,7 +1479,6 @@ impl Translator<'_> {
             loop_body,
         });
         self.emit_location(label, node);
-        post_emit!(LoopExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1627,7 +1486,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroCall,
     ) -> Option<Label<generated::MacroCall>> {
-        pre_emit!(MacroCall, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1645,7 +1506,7 @@ impl Translator<'_> {
             token_tree,
         });
         self.emit_location(label, node);
-        post_emit!(MacroCall, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1653,7 +1514,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroDef,
     ) -> Option<Label<generated::MacroDef>> {
-        pre_emit!(MacroDef, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1679,7 +1539,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(MacroDef, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1687,14 +1546,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroExpr,
     ) -> Option<Label<generated::MacroExpr>> {
-        pre_emit!(MacroExpr, self, node);
         let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x));
         let label = self.trap.emit(generated::MacroExpr {
             id: TrapId::Star,
             macro_call,
         });
         self.emit_location(label, node);
-        post_emit!(MacroExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1702,14 +1559,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroItems,
     ) -> Option<Label<generated::MacroItems>> {
-        pre_emit!(MacroItems, self, node);
         let items = node.items().filter_map(|x| self.emit_item(&x)).collect();
         let label = self.trap.emit(generated::MacroItems {
             id: TrapId::Star,
             items,
         });
         self.emit_location(label, node);
-        post_emit!(MacroItems, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1717,14 +1572,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroPat,
     ) -> Option<Label<generated::MacroPat>> {
-        pre_emit!(MacroPat, self, node);
         let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x));
         let label = self.trap.emit(generated::MacroPat {
             id: TrapId::Star,
             macro_call,
         });
         self.emit_location(label, node);
-        post_emit!(MacroPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1732,7 +1585,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroRules,
     ) -> Option<Label<generated::MacroRules>> {
-        pre_emit!(MacroRules, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1748,7 +1600,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(MacroRules, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1756,7 +1607,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroStmts,
     ) -> Option<Label<generated::MacroBlockExpr>> {
-        pre_emit!(MacroBlockExpr, self, node);
         let tail_expr = node.expr().and_then(|x| self.emit_expr(&x));
         let statements = node
             .statements()
@@ -1768,7 +1618,6 @@ impl Translator<'_> {
             statements,
         });
         self.emit_location(label, node);
-        post_emit!(MacroBlockExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1776,14 +1625,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MacroType,
     ) -> Option<Label<generated::MacroTypeRepr>> {
-        pre_emit!(MacroTypeRepr, self, node);
         let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x));
         let label = self.trap.emit(generated::MacroTypeRepr {
             id: TrapId::Star,
             macro_call,
         });
         self.emit_location(label, node);
-        post_emit!(MacroTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1791,7 +1638,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MatchArm,
     ) -> Option<Label<generated::MatchArm>> {
-        pre_emit!(MatchArm, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1807,7 +1653,6 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(MatchArm, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1815,7 +1660,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MatchArmList,
     ) -> Option<Label<generated::MatchArmList>> {
-        pre_emit!(MatchArmList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1830,7 +1674,6 @@ impl Translator<'_> {
             attrs,
         });
         self.emit_location(label, node);
-        post_emit!(MatchArmList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1838,7 +1681,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MatchExpr,
     ) -> Option<Label<generated::MatchExpr>> {
-        pre_emit!(MatchExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1854,7 +1696,6 @@ impl Translator<'_> {
             match_arm_list,
         });
         self.emit_location(label, node);
-        post_emit!(MatchExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1862,19 +1703,19 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MatchGuard,
     ) -> Option<Label<generated::MatchGuard>> {
-        pre_emit!(MatchGuard, self, node);
         let condition = node.condition().and_then(|x| self.emit_expr(&x));
         let label = self.trap.emit(generated::MatchGuard {
             id: TrapId::Star,
             condition,
         });
         self.emit_location(label, node);
-        post_emit!(MatchGuard, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_meta(&mut self, node: &ast::Meta) -> Option<Label<generated::Meta>> {
-        pre_emit!(Meta, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let expr = node.expr().and_then(|x| self.emit_expr(&x));
         let is_unsafe = node.unsafe_token().is_some();
         let path = node.path().and_then(|x| self.emit_path(&x));
@@ -1887,7 +1728,7 @@ impl Translator<'_> {
             token_tree,
         });
         self.emit_location(label, node);
-        post_emit!(Meta, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1895,7 +1736,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::MethodCallExpr,
     ) -> Option<Label<generated::MethodCallExpr>> {
-        pre_emit!(MethodCallExpr, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1915,12 +1758,14 @@ impl Translator<'_> {
             receiver,
         });
         self.emit_location(label, node);
-        post_emit!(MethodCallExpr, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_module(&mut self, node: &ast::Module) -> Option<Label<generated::Module>> {
-        pre_emit!(Module, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -1936,19 +1781,17 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(Module, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_name(&mut self, node: &ast::Name) -> Option<Label<generated::Name>> {
-        pre_emit!(Name, self, node);
         let text = node.try_get_text();
         let label = self.trap.emit(generated::Name {
             id: TrapId::Star,
             text,
         });
         self.emit_location(label, node);
-        post_emit!(Name, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1956,14 +1799,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::NameRef,
     ) -> Option<Label<generated::NameRef>> {
-        pre_emit!(NameRef, self, node);
         let text = node.try_get_text();
         let label = self.trap.emit(generated::NameRef {
             id: TrapId::Star,
             text,
         });
         self.emit_location(label, node);
-        post_emit!(NameRef, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1971,12 +1812,10 @@ impl Translator<'_> {
         &mut self,
         node: &ast::NeverType,
     ) -> Option<Label<generated::NeverTypeRepr>> {
-        pre_emit!(NeverTypeRepr, self, node);
         let label = self
             .trap
             .emit(generated::NeverTypeRepr { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(NeverTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -1984,7 +1823,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::OffsetOfExpr,
     ) -> Option<Label<generated::OffsetOfExpr>> {
-        pre_emit!(OffsetOfExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2001,24 +1839,20 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(OffsetOfExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_or_pat(&mut self, node: &ast::OrPat) -> Option<Label<generated::OrPat>> {
-        pre_emit!(OrPat, self, node);
         let pats = node.pats().filter_map(|x| self.emit_pat(&x)).collect();
         let label = self.trap.emit(generated::OrPat {
             id: TrapId::Star,
             pats,
         });
         self.emit_location(label, node);
-        post_emit!(OrPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_param(&mut self, node: &ast::Param) -> Option<Label<generated::Param>> {
-        pre_emit!(Param, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2036,7 +1870,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(Param, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2044,7 +1877,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ParamList,
     ) -> Option<Label<generated::ParamList>> {
-        pre_emit!(ParamList, self, node);
         let params = node.params().filter_map(|x| self.emit_param(&x)).collect();
         let self_param = node.self_param().and_then(|x| self.emit_self_param(&x));
         let label = self.trap.emit(generated::ParamList {
@@ -2053,7 +1885,6 @@ impl Translator<'_> {
             self_param,
         });
         self.emit_location(label, node);
-        post_emit!(ParamList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2061,7 +1892,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ParenExpr,
     ) -> Option<Label<generated::ParenExpr>> {
-        pre_emit!(ParenExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2073,7 +1903,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(ParenExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2081,14 +1910,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ParenPat,
     ) -> Option<Label<generated::ParenPat>> {
-        pre_emit!(ParenPat, self, node);
         let pat = node.pat().and_then(|x| self.emit_pat(&x));
         let label = self.trap.emit(generated::ParenPat {
             id: TrapId::Star,
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(ParenPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2096,14 +1923,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ParenType,
     ) -> Option<Label<generated::ParenTypeRepr>> {
-        pre_emit!(ParenTypeRepr, self, node);
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
         let label = self.trap.emit(generated::ParenTypeRepr {
             id: TrapId::Star,
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(ParenTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2111,7 +1936,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ParenthesizedArgList,
     ) -> Option<Label<generated::ParenthesizedArgList>> {
-        pre_emit!(ParenthesizedArgList, self, node);
         let type_args = node
             .type_args()
             .filter_map(|x| self.emit_type_arg(&x))
@@ -2121,12 +1945,10 @@ impl Translator<'_> {
             type_args,
         });
         self.emit_location(label, node);
-        post_emit!(ParenthesizedArgList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_path(&mut self, node: &ast::Path) -> Option<Label<generated::Path>> {
-        pre_emit!(Path, self, node);
         let qualifier = node.qualifier().and_then(|x| self.emit_path(&x));
         let segment = node.segment().and_then(|x| self.emit_path_segment(&x));
         let label = self.trap.emit(generated::Path {
@@ -2135,7 +1957,6 @@ impl Translator<'_> {
             segment,
         });
         self.emit_location(label, node);
-        post_emit!(Path, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2143,7 +1964,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PathExpr,
     ) -> Option<Label<generated::PathExpr>> {
-        pre_emit!(PathExpr, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2155,7 +1978,7 @@ impl Translator<'_> {
             path,
         });
         self.emit_location(label, node);
-        post_emit!(PathExpr, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2163,14 +1986,16 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PathPat,
     ) -> Option<Label<generated::PathPat>> {
-        pre_emit!(PathPat, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let path = node.path().and_then(|x| self.emit_path(&x));
         let label = self.trap.emit(generated::PathPat {
             id: TrapId::Star,
             path,
         });
         self.emit_location(label, node);
-        post_emit!(PathPat, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2178,7 +2003,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PathSegment,
     ) -> Option<Label<generated::PathSegment>> {
-        pre_emit!(PathSegment, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let generic_arg_list = node
             .generic_arg_list()
             .and_then(|x| self.emit_generic_arg_list(&x));
@@ -2199,7 +2026,7 @@ impl Translator<'_> {
             return_type_syntax,
         });
         self.emit_location(label, node);
-        post_emit!(PathSegment, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2207,14 +2034,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PathType,
     ) -> Option<Label<generated::PathTypeRepr>> {
-        pre_emit!(PathTypeRepr, self, node);
         let path = node.path().and_then(|x| self.emit_path(&x));
         let label = self.trap.emit(generated::PathTypeRepr {
             id: TrapId::Star,
             path,
         });
         self.emit_location(label, node);
-        post_emit!(PathTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2222,7 +2047,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PrefixExpr,
     ) -> Option<Label<generated::PrefixExpr>> {
-        pre_emit!(PrefixExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2236,7 +2060,6 @@ impl Translator<'_> {
             operator_name,
         });
         self.emit_location(label, node);
-        post_emit!(PrefixExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2244,7 +2067,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::PtrType,
     ) -> Option<Label<generated::PtrTypeRepr>> {
-        pre_emit!(PtrTypeRepr, self, node);
         let is_const = node.const_token().is_some();
         let is_mut = node.mut_token().is_some();
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
@@ -2255,7 +2077,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(PtrTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2263,7 +2084,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RangeExpr,
     ) -> Option<Label<generated::RangeExpr>> {
-        pre_emit!(RangeExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2279,7 +2099,6 @@ impl Translator<'_> {
             start,
         });
         self.emit_location(label, node);
-        post_emit!(RangeExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2287,7 +2106,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RangePat,
     ) -> Option<Label<generated::RangePat>> {
-        pre_emit!(RangePat, self, node);
         let end = node.end().and_then(|x| self.emit_pat(&x));
         let operator_name = node.try_get_text();
         let start = node.start().and_then(|x| self.emit_pat(&x));
@@ -2298,7 +2116,6 @@ impl Translator<'_> {
             start,
         });
         self.emit_location(label, node);
-        post_emit!(RangePat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2306,7 +2123,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordExpr,
     ) -> Option<Label<generated::StructExpr>> {
-        pre_emit!(StructExpr, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let path = node.path().and_then(|x| self.emit_path(&x));
         let struct_expr_field_list = node
             .record_expr_field_list()
@@ -2317,7 +2136,7 @@ impl Translator<'_> {
             struct_expr_field_list,
         });
         self.emit_location(label, node);
-        post_emit!(StructExpr, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2325,7 +2144,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordExprField,
     ) -> Option<Label<generated::StructExprField>> {
-        pre_emit!(StructExprField, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2339,7 +2157,6 @@ impl Translator<'_> {
             identifier,
         });
         self.emit_location(label, node);
-        post_emit!(StructExprField, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2347,7 +2164,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordExprFieldList,
     ) -> Option<Label<generated::StructExprFieldList>> {
-        pre_emit!(StructExprFieldList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2364,7 +2180,6 @@ impl Translator<'_> {
             spread,
         });
         self.emit_location(label, node);
-        post_emit!(StructExprFieldList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2372,7 +2187,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordField,
     ) -> Option<Label<generated::StructField>> {
-        pre_emit!(StructField, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2392,7 +2206,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(StructField, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2400,7 +2213,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordFieldList,
     ) -> Option<Label<generated::StructFieldList>> {
-        pre_emit!(StructFieldList, self, node);
         let fields = node
             .fields()
             .filter_map(|x| self.emit_record_field(&x))
@@ -2410,7 +2222,6 @@ impl Translator<'_> {
             fields,
         });
         self.emit_location(label, node);
-        post_emit!(StructFieldList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2418,7 +2229,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordPat,
     ) -> Option<Label<generated::StructPat>> {
-        pre_emit!(StructPat, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let path = node.path().and_then(|x| self.emit_path(&x));
         let struct_pat_field_list = node
             .record_pat_field_list()
@@ -2429,7 +2242,7 @@ impl Translator<'_> {
             struct_pat_field_list,
         });
         self.emit_location(label, node);
-        post_emit!(StructPat, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2437,7 +2250,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordPatField,
     ) -> Option<Label<generated::StructPatField>> {
-        pre_emit!(StructPatField, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2451,7 +2263,6 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(StructPatField, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2459,7 +2270,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RecordPatFieldList,
     ) -> Option<Label<generated::StructPatFieldList>> {
-        pre_emit!(StructPatFieldList, self, node);
         let fields = node
             .fields()
             .filter_map(|x| self.emit_record_pat_field(&x))
@@ -2471,7 +2281,6 @@ impl Translator<'_> {
             rest_pat,
         });
         self.emit_location(label, node);
-        post_emit!(StructPatFieldList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2479,7 +2288,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RefExpr,
     ) -> Option<Label<generated::RefExpr>> {
-        pre_emit!(RefExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2497,12 +2305,10 @@ impl Translator<'_> {
             is_raw,
         });
         self.emit_location(label, node);
-        post_emit!(RefExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_ref_pat(&mut self, node: &ast::RefPat) -> Option<Label<generated::RefPat>> {
-        pre_emit!(RefPat, self, node);
         let is_mut = node.mut_token().is_some();
         let pat = node.pat().and_then(|x| self.emit_pat(&x));
         let label = self.trap.emit(generated::RefPat {
@@ -2511,7 +2317,6 @@ impl Translator<'_> {
             pat,
         });
         self.emit_location(label, node);
-        post_emit!(RefPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2519,7 +2324,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RefType,
     ) -> Option<Label<generated::RefTypeRepr>> {
-        pre_emit!(RefTypeRepr, self, node);
         let is_mut = node.mut_token().is_some();
         let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x));
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
@@ -2530,19 +2334,16 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(RefTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_rename(&mut self, node: &ast::Rename) -> Option<Label<generated::Rename>> {
-        pre_emit!(Rename, self, node);
         let name = node.name().and_then(|x| self.emit_name(&x));
         let label = self.trap.emit(generated::Rename {
             id: TrapId::Star,
             name,
         });
         self.emit_location(label, node);
-        post_emit!(Rename, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2550,7 +2351,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RestPat,
     ) -> Option<Label<generated::RestPat>> {
-        pre_emit!(RestPat, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2560,7 +2360,6 @@ impl Translator<'_> {
             attrs,
         });
         self.emit_location(label, node);
-        post_emit!(RestPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2568,14 +2367,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::RetType,
     ) -> Option<Label<generated::RetTypeRepr>> {
-        pre_emit!(RetTypeRepr, self, node);
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
         let label = self.trap.emit(generated::RetTypeRepr {
             id: TrapId::Star,
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(RetTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2583,7 +2380,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ReturnExpr,
     ) -> Option<Label<generated::ReturnExpr>> {
-        pre_emit!(ReturnExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2595,7 +2391,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(ReturnExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2603,12 +2398,10 @@ impl Translator<'_> {
         &mut self,
         node: &ast::ReturnTypeSyntax,
     ) -> Option<Label<generated::ReturnTypeSyntax>> {
-        pre_emit!(ReturnTypeSyntax, self, node);
         let label = self
             .trap
             .emit(generated::ReturnTypeSyntax { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(ReturnTypeSyntax, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2616,7 +2409,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::SelfParam,
     ) -> Option<Label<generated::SelfParam>> {
-        pre_emit!(SelfParam, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2636,7 +2428,6 @@ impl Translator<'_> {
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(SelfParam, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2644,14 +2435,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::SlicePat,
     ) -> Option<Label<generated::SlicePat>> {
-        pre_emit!(SlicePat, self, node);
         let pats = node.pats().filter_map(|x| self.emit_pat(&x)).collect();
         let label = self.trap.emit(generated::SlicePat {
             id: TrapId::Star,
             pats,
         });
         self.emit_location(label, node);
-        post_emit!(SlicePat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2659,14 +2448,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::SliceType,
     ) -> Option<Label<generated::SliceTypeRepr>> {
-        pre_emit!(SliceTypeRepr, self, node);
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
         let label = self.trap.emit(generated::SliceTypeRepr {
             id: TrapId::Star,
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(SliceTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2674,7 +2461,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::SourceFile,
     ) -> Option<Label<generated::SourceFile>> {
-        pre_emit!(SourceFile, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2686,12 +2472,10 @@ impl Translator<'_> {
             items,
         });
         self.emit_location(label, node);
-        post_emit!(SourceFile, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_static(&mut self, node: &ast::Static) -> Option<Label<generated::Static>> {
-        pre_emit!(Static, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2719,7 +2503,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(Static, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2727,7 +2510,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::StmtList,
     ) -> Option<Label<generated::StmtList>> {
-        pre_emit!(StmtList, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2744,12 +2526,13 @@ impl Translator<'_> {
             tail_expr,
         });
         self.emit_location(label, node);
-        post_emit!(StmtList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_struct(&mut self, node: &ast::Struct) -> Option<Label<generated::Struct>> {
-        pre_emit!(Struct, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2771,7 +2554,7 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Struct, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2779,15 +2562,15 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TokenTree,
     ) -> Option<Label<generated::TokenTree>> {
-        pre_emit!(TokenTree, self, node);
         let label = self.trap.emit(generated::TokenTree { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(TokenTree, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_trait(&mut self, node: &ast::Trait) -> Option<Label<generated::Trait>> {
-        pre_emit!(Trait, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2819,7 +2602,7 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Trait, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2827,7 +2610,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TraitAlias,
     ) -> Option<Label<generated::TraitAlias>> {
-        pre_emit!(TraitAlias, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2851,7 +2633,6 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(TraitAlias, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2859,7 +2640,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TryExpr,
     ) -> Option<Label<generated::TryExpr>> {
-        pre_emit!(TryExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2871,7 +2651,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(TryExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2879,7 +2658,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TupleExpr,
     ) -> Option<Label<generated::TupleExpr>> {
-        pre_emit!(TupleExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2891,7 +2669,6 @@ impl Translator<'_> {
             fields,
         });
         self.emit_location(label, node);
-        post_emit!(TupleExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2899,7 +2676,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TupleField,
     ) -> Option<Label<generated::TupleField>> {
-        pre_emit!(TupleField, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -2913,7 +2689,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(TupleField, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2921,7 +2696,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TupleFieldList,
     ) -> Option<Label<generated::TupleFieldList>> {
-        pre_emit!(TupleFieldList, self, node);
         let fields = node
             .fields()
             .filter_map(|x| self.emit_tuple_field(&x))
@@ -2931,7 +2705,6 @@ impl Translator<'_> {
             fields,
         });
         self.emit_location(label, node);
-        post_emit!(TupleFieldList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2939,14 +2712,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TuplePat,
     ) -> Option<Label<generated::TuplePat>> {
-        pre_emit!(TuplePat, self, node);
         let fields = node.fields().filter_map(|x| self.emit_pat(&x)).collect();
         let label = self.trap.emit(generated::TuplePat {
             id: TrapId::Star,
             fields,
         });
         self.emit_location(label, node);
-        post_emit!(TuplePat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2954,7 +2725,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TupleStructPat,
     ) -> Option<Label<generated::TupleStructPat>> {
-        pre_emit!(TupleStructPat, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         let fields = node.fields().filter_map(|x| self.emit_pat(&x)).collect();
         let path = node.path().and_then(|x| self.emit_path(&x));
         let label = self.trap.emit(generated::TupleStructPat {
@@ -2963,7 +2736,7 @@ impl Translator<'_> {
             path,
         });
         self.emit_location(label, node);
-        post_emit!(TupleStructPat, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2971,14 +2744,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TupleType,
     ) -> Option<Label<generated::TupleTypeRepr>> {
-        pre_emit!(TupleTypeRepr, self, node);
         let fields = node.fields().filter_map(|x| self.emit_type(&x)).collect();
         let label = self.trap.emit(generated::TupleTypeRepr {
             id: TrapId::Star,
             fields,
         });
         self.emit_location(label, node);
-        post_emit!(TupleTypeRepr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -2986,7 +2757,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TypeAlias,
     ) -> Option<Label<generated::TypeAlias>> {
-        pre_emit!(TypeAlias, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3014,7 +2784,6 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(TypeAlias, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3022,14 +2791,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TypeArg,
     ) -> Option<Label<generated::TypeArg>> {
-        pre_emit!(TypeArg, self, node);
         let type_repr = node.ty().and_then(|x| self.emit_type(&x));
         let label = self.trap.emit(generated::TypeArg {
             id: TrapId::Star,
             type_repr,
         });
         self.emit_location(label, node);
-        post_emit!(TypeArg, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3037,7 +2804,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TypeBound,
     ) -> Option<Label<generated::TypeBound>> {
-        pre_emit!(TypeBound, self, node);
         let is_async = node.async_token().is_some();
         let is_const = node.const_token().is_some();
         let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x));
@@ -3054,7 +2820,6 @@ impl Translator<'_> {
             use_bound_generic_args,
         });
         self.emit_location(label, node);
-        post_emit!(TypeBound, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3062,7 +2827,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TypeBoundList,
     ) -> Option<Label<generated::TypeBoundList>> {
-        pre_emit!(TypeBoundList, self, node);
         let bounds = node
             .bounds()
             .filter_map(|x| self.emit_type_bound(&x))
@@ -3072,7 +2836,6 @@ impl Translator<'_> {
             bounds,
         });
         self.emit_location(label, node);
-        post_emit!(TypeBoundList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3080,7 +2843,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::TypeParam,
     ) -> Option<Label<generated::TypeParam>> {
-        pre_emit!(TypeParam, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3098,7 +2860,6 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(TypeParam, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3106,7 +2867,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::UnderscoreExpr,
     ) -> Option<Label<generated::UnderscoreExpr>> {
-        pre_emit!(UnderscoreExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3116,12 +2876,13 @@ impl Translator<'_> {
             attrs,
         });
         self.emit_location(label, node);
-        post_emit!(UnderscoreExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_union(&mut self, node: &ast::Union) -> Option<Label<generated::Union>> {
-        pre_emit!(Union, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3145,12 +2906,11 @@ impl Translator<'_> {
             where_clause,
         });
         self.emit_location(label, node);
-        post_emit!(Union, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
     pub(crate) fn emit_use(&mut self, node: &ast::Use) -> Option<Label<generated::Use>> {
-        pre_emit!(Use, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3164,7 +2924,6 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(Use, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3172,7 +2931,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::UseBoundGenericArgs,
     ) -> Option<Label<generated::UseBoundGenericArgs>> {
-        pre_emit!(UseBoundGenericArgs, self, node);
         let use_bound_generic_args = node
             .use_bound_generic_args()
             .filter_map(|x| self.emit_use_bound_generic_arg(&x))
@@ -3182,7 +2940,6 @@ impl Translator<'_> {
             use_bound_generic_args,
         });
         self.emit_location(label, node);
-        post_emit!(UseBoundGenericArgs, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3190,7 +2947,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::UseTree,
     ) -> Option<Label<generated::UseTree>> {
-        pre_emit!(UseTree, self, node);
         let is_glob = node.star_token().is_some();
         let path = node.path().and_then(|x| self.emit_path(&x));
         let rename = node.rename().and_then(|x| self.emit_rename(&x));
@@ -3205,7 +2961,6 @@ impl Translator<'_> {
             use_tree_list,
         });
         self.emit_location(label, node);
-        post_emit!(UseTree, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3213,7 +2968,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::UseTreeList,
     ) -> Option<Label<generated::UseTreeList>> {
-        pre_emit!(UseTreeList, self, node);
         let use_trees = node
             .use_trees()
             .filter_map(|x| self.emit_use_tree(&x))
@@ -3223,7 +2977,6 @@ impl Translator<'_> {
             use_trees,
         });
         self.emit_location(label, node);
-        post_emit!(UseTreeList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3231,7 +2984,9 @@ impl Translator<'_> {
         &mut self,
         node: &ast::Variant,
     ) -> Option<Label<generated::Variant>> {
-        pre_emit!(Variant, self, node);
+        if let Some(label) = self.pre_emit(node) {
+            return Some(label);
+        }
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3249,7 +3004,7 @@ impl Translator<'_> {
             visibility,
         });
         self.emit_location(label, node);
-        post_emit!(Variant, self, node, label);
+        self.post_emit(node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3257,7 +3012,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::VariantList,
     ) -> Option<Label<generated::VariantList>> {
-        pre_emit!(VariantList, self, node);
         let variants = node
             .variants()
             .filter_map(|x| self.emit_variant(&x))
@@ -3267,7 +3021,6 @@ impl Translator<'_> {
             variants,
         });
         self.emit_location(label, node);
-        post_emit!(VariantList, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3275,14 +3028,12 @@ impl Translator<'_> {
         &mut self,
         node: &ast::Visibility,
     ) -> Option<Label<generated::Visibility>> {
-        pre_emit!(Visibility, self, node);
         let path = node.path().and_then(|x| self.emit_path(&x));
         let label = self.trap.emit(generated::Visibility {
             id: TrapId::Star,
             path,
         });
         self.emit_location(label, node);
-        post_emit!(Visibility, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3290,7 +3041,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::WhereClause,
     ) -> Option<Label<generated::WhereClause>> {
-        pre_emit!(WhereClause, self, node);
         let predicates = node
             .predicates()
             .filter_map(|x| self.emit_where_pred(&x))
@@ -3300,7 +3050,6 @@ impl Translator<'_> {
             predicates,
         });
         self.emit_location(label, node);
-        post_emit!(WhereClause, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3308,7 +3057,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::WherePred,
     ) -> Option<Label<generated::WherePred>> {
-        pre_emit!(WherePred, self, node);
         let generic_param_list = node
             .generic_param_list()
             .and_then(|x| self.emit_generic_param_list(&x));
@@ -3325,7 +3073,6 @@ impl Translator<'_> {
             type_bound_list,
         });
         self.emit_location(label, node);
-        post_emit!(WherePred, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3333,7 +3080,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::WhileExpr,
     ) -> Option<Label<generated::WhileExpr>> {
-        pre_emit!(WhileExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3349,7 +3095,6 @@ impl Translator<'_> {
             loop_body,
         });
         self.emit_location(label, node);
-        post_emit!(WhileExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3357,10 +3102,8 @@ impl Translator<'_> {
         &mut self,
         node: &ast::WildcardPat,
     ) -> Option<Label<generated::WildcardPat>> {
-        pre_emit!(WildcardPat, self, node);
         let label = self.trap.emit(generated::WildcardPat { id: TrapId::Star });
         self.emit_location(label, node);
-        post_emit!(WildcardPat, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3368,7 +3111,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::YeetExpr,
     ) -> Option<Label<generated::YeetExpr>> {
-        pre_emit!(YeetExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3380,7 +3122,6 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(YeetExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
@@ -3388,7 +3129,6 @@ impl Translator<'_> {
         &mut self,
         node: &ast::YieldExpr,
     ) -> Option<Label<generated::YieldExpr>> {
-        pre_emit!(YieldExpr, self, node);
         if self.should_be_excluded(node) {
             return None;
         }
@@ -3400,8 +3140,67 @@ impl Translator<'_> {
             expr,
         });
         self.emit_location(label, node);
-        post_emit!(YieldExpr, self, node, label);
         self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
         Some(label)
     }
 }
+impl HasTrapClass for ast::AssocItem {
+    type TrapClass = generated::AssocItem;
+}
+impl HasTrapClass for ast::ExternItem {
+    type TrapClass = generated::ExternItem;
+}
+impl HasTrapClass for ast::Item {
+    type TrapClass = generated::Item;
+}
+impl HasTrapClass for ast::Const {
+    type TrapClass = generated::Const;
+}
+impl HasTrapClass for ast::Enum {
+    type TrapClass = generated::Enum;
+}
+impl HasTrapClass for ast::Fn {
+    type TrapClass = generated::Function;
+}
+impl HasTrapClass for ast::MacroCall {
+    type TrapClass = generated::MacroCall;
+}
+impl HasTrapClass for ast::Meta {
+    type TrapClass = generated::Meta;
+}
+impl HasTrapClass for ast::MethodCallExpr {
+    type TrapClass = generated::MethodCallExpr;
+}
+impl HasTrapClass for ast::Module {
+    type TrapClass = generated::Module;
+}
+impl HasTrapClass for ast::PathExpr {
+    type TrapClass = generated::PathExpr;
+}
+impl HasTrapClass for ast::PathPat {
+    type TrapClass = generated::PathPat;
+}
+impl HasTrapClass for ast::PathSegment {
+    type TrapClass = generated::PathSegment;
+}
+impl HasTrapClass for ast::RecordExpr {
+    type TrapClass = generated::StructExpr;
+}
+impl HasTrapClass for ast::RecordPat {
+    type TrapClass = generated::StructPat;
+}
+impl HasTrapClass for ast::Struct {
+    type TrapClass = generated::Struct;
+}
+impl HasTrapClass for ast::Trait {
+    type TrapClass = generated::Trait;
+}
+impl HasTrapClass for ast::TupleStructPat {
+    type TrapClass = generated::TupleStructPat;
+}
+impl HasTrapClass for ast::Union {
+    type TrapClass = generated::Union;
+}
+impl HasTrapClass for ast::Variant {
+    type TrapClass = generated::Variant;
+}
diff --git a/rust/extractor/src/translate/mappings.rs b/rust/extractor/src/translate/mappings.rs
index 3068e5cea52..3e71c6deb14 100644
--- a/rust/extractor/src/translate/mappings.rs
+++ b/rust/extractor/src/translate/mappings.rs
@@ -1,7 +1,20 @@
+use crate::trap::{Label, TrapClass};
 use ra_ap_hir::{Enum, Function, HasContainer, Module, Semantics, Struct, Trait, Union};
 use ra_ap_ide_db::RootDatabase;
 use ra_ap_syntax::{AstNode, ast, ast::RangeItem};
 
+pub(crate) trait HasTrapClass: AstNode {
+    type TrapClass: TrapClass;
+}
+
+pub(crate) trait Emission<T: HasTrapClass> {
+    fn pre_emit(&mut self, _node: &T) -> Option<Label<T::TrapClass>> {
+        None
+    }
+
+    fn post_emit(&mut self, _node: &T, _label: Label<T::TrapClass>) {}
+}
+
 pub(crate) trait TextValue {
     fn try_get_text(&self) -> Option<String>;
 }