From 61c3aa62887ca8ff3a23f08cbc620463b6dd5331 Mon Sep 17 00:00:00 2001
From: Paolo Tranquilli <redsun82@gihub.com>
Date: Tue, 8 Oct 2024 10:37:53 +0200
Subject: [PATCH] Rust: integrate rust code generation into `//rust/codegen`

---
 rust/ast-generator/BUILD.bazel            |   7 +
 rust/ast-generator/src/codegen.rs         |   2 +-
 rust/ast-generator/src/main.rs            |  24 +-
 rust/codegen/BUILD.bazel                  |  24 +-
 rust/codegen/codegen.sh                   |  13 +
 rust/extractor/src/translate/generated.rs | 396 ++++++----------------
 6 files changed, 148 insertions(+), 318 deletions(-)
 create mode 100755 rust/codegen/codegen.sh

diff --git a/rust/ast-generator/BUILD.bazel b/rust/ast-generator/BUILD.bazel
index 19c078e2342..2449dfa1d32 100644
--- a/rust/ast-generator/BUILD.bazel
+++ b/rust/ast-generator/BUILD.bazel
@@ -1,3 +1,4 @@
+load("@tree_sitter_extractors_deps//:defs.bzl", "aliases", "all_crate_deps")
 load("//misc/bazel:rust.bzl", "codeql_rust_binary")
 
 codeql_rust_binary(
@@ -12,3 +13,9 @@ codeql_rust_binary(
         normal = True,
     ),
 )
+
+filegroup(
+    name = "manifest",
+    srcs = ["Cargo.toml"],
+    visibility = ["//rust:__subpackages__"],
+)
diff --git a/rust/ast-generator/src/codegen.rs b/rust/ast-generator/src/codegen.rs
index 337a42bef19..6d66eeab5fe 100644
--- a/rust/ast-generator/src/codegen.rs
+++ b/rust/ast-generator/src/codegen.rs
@@ -12,5 +12,5 @@ pub fn ensure_file_contents(
     contents: &String,
     _check: bool,
 ) {
-    std::fs::write(path, contents).expect("Unable to write file");
+    std::fs::write(path, contents).unwrap_or_else(|_| panic!("Unable to write {}", path.display()));
 }
diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs
index 4d0c1acd81e..8d4114c8bde 100644
--- a/rust/ast-generator/src/main.rs
+++ b/rust/ast-generator/src/main.rs
@@ -57,7 +57,7 @@ fn write_schema(
         buf,
         "# Generated by `ast-generator`, do not edit by hand.\n"
     )?;
-    writeln!(buf, "from .prelude import *\n")?;
+    writeln!(buf, "from .prelude import *")?;
 
     for node in &grammar.enums {
         let super_classses = if let Some(cls) = super_types.get(&node.name) {
@@ -66,9 +66,13 @@ fn write_schema(
         } else {
             "AstNode".to_owned()
         };
-        writeln!(buf, "class {}({}):", class_name(&node.name), super_classses)?;
+        writeln!(
+            buf,
+            "\nclass {}({}):",
+            class_name(&node.name),
+            super_classses
+        )?;
         writeln!(buf, "   pass")?;
-        writeln!(buf)?;
     }
     for node in &grammar.nodes {
         let super_classses = if let Some(cls) = super_types.get(&node.name) {
@@ -77,7 +81,12 @@ fn write_schema(
         } else {
             "AstNode".to_owned()
         };
-        writeln!(buf, "class {}({}):", class_name(&node.name), super_classses)?;
+        writeln!(
+            buf,
+            "\nclass {}({}):",
+            class_name(&node.name),
+            super_classses
+        )?;
         let mut empty = true;
         for field in get_fields(node) {
             if field.tp == "SyntaxToken" {
@@ -111,7 +120,6 @@ fn write_schema(
         if empty {
             writeln!(buf, "   pass")?;
         }
-        writeln!(buf)?;
     }
     Ok(String::from_utf8_lossy(&buf).to_string())
 }
@@ -409,6 +417,8 @@ fn write_extractor(grammar: &AstSrc) -> std::io::Result<String> {
     writeln!(
         buf,
         "//! Generated by `ast-generator`, do not edit by hand.\n
+#![cfg_attr(any(), rustfmt::skip)]
+
 use crate::generated;
 use super::base::{{TextValue, Translator}};
 use crate::trap::{{Label, TrapId}};
@@ -548,7 +558,7 @@ fn main() -> std::io::Result<()> {
         super_class_x.cmp(&super_class_y).then(x.name.cmp(&y.name))
     });
     let schema = write_schema(&grammar, super_types)?;
-    let schema_path = PathBuf::from("../schema/ast.py");
+    let schema_path = project_root().join("schema/ast.py");
     codegen::ensure_file_contents(
         crate::flags::CodegenType::Grammar,
         &schema_path,
@@ -557,7 +567,7 @@ fn main() -> std::io::Result<()> {
     );
 
     let extractor = write_extractor(&grammar)?;
-    let extractor_path = PathBuf::from("../extractor/src/translate/generated.rs");
+    let extractor_path = project_root().join("extractor/src/translate/generated.rs");
     codegen::ensure_file_contents(
         crate::flags::CodegenType::Grammar,
         &extractor_path,
diff --git a/rust/codegen/BUILD.bazel b/rust/codegen/BUILD.bazel
index 99f737538a6..43e057a6fbf 100644
--- a/rust/codegen/BUILD.bazel
+++ b/rust/codegen/BUILD.bazel
@@ -1,15 +1,17 @@
-load("@bazel_skylib//rules:native_binary.bzl", "native_binary")
+_args = [
+    "//rust/ast-generator",
+    "//rust/ast-generator:manifest",
+    "//misc/codegen",
+    "//rust:codegen-conf",
+]
 
-native_binary(
+sh_binary(
     name = "codegen",
-    src = "//misc/codegen",
-    out = "codegen",
-    args = [
-        "--configuration-file=$(location //rust:codegen-conf)",
-    ],
-    data = [
-        "//rust:codegen-conf",
-        "//rust:schema",
-    ],
+    srcs = ["codegen.sh"],
+    args = ["$(rlocationpath %s)" % a for a in _args],
+    data = _args,
     visibility = ["//rust:__subpackages__"],
+    deps = [
+        "//misc/bazel:sh_runfiles",
+    ],
 )
diff --git a/rust/codegen/codegen.sh b/rust/codegen/codegen.sh
new file mode 100755
index 00000000000..e56f40627e6
--- /dev/null
+++ b/rust/codegen/codegen.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -eu
+
+source misc/bazel/runfiles.sh 2>/dev/null || source external/ql~/misc/bazel/runfiles.sh
+
+ast_generator="$(rlocation "$1")"
+ast_generator_manifest="$(rlocation "$2")"
+codegen="$(rlocation "$3")"
+codegen_conf="$(rlocation "$4")"
+
+CARGO_MANIFEST_DIR="$(dirname "$ast_generator_manifest")" "$ast_generator"
+"$codegen" --configuration-file="$codegen_conf"
diff --git a/rust/extractor/src/translate/generated.rs b/rust/extractor/src/translate/generated.rs
index f6f2df6483b..57d3cbc186b 100644
--- a/rust/extractor/src/translate/generated.rs
+++ b/rust/extractor/src/translate/generated.rs
@@ -1,7 +1,9 @@
 //! Generated by `ast-generator`, do not edit by hand.
 
-use super::base::{TextValue, Translator};
+#![cfg_attr(any(), rustfmt::skip)]
+
 use crate::generated;
+use super::base::{TextValue, Translator};
 use crate::trap::{Label, TrapId};
 use ra_ap_syntax::ast::{
     HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasModuleItem, HasName,
@@ -67,10 +69,7 @@ impl Translator {
         }
     }
 
-    pub(crate) fn emit_extern_item(
-        &mut self,
-        node: ast::ExternItem,
-    ) -> Label<generated::ExternItem> {
+    pub(crate) fn emit_extern_item(&mut self, node: ast::ExternItem) -> Label<generated::ExternItem> {
         match node {
             ast::ExternItem::Fn(inner) => self.emit_fn(inner).into(),
             ast::ExternItem::MacroCall(inner) => self.emit_macro_call(inner).into(),
@@ -86,10 +85,7 @@ impl Translator {
         }
     }
 
-    pub(crate) fn emit_generic_arg(
-        &mut self,
-        node: ast::GenericArg,
-    ) -> Label<generated::GenericArg> {
+    pub(crate) fn emit_generic_arg(&mut self, node: ast::GenericArg) -> Label<generated::GenericArg> {
         match node {
             ast::GenericArg::AssocTypeArg(inner) => self.emit_assoc_type_arg(inner).into(),
             ast::GenericArg::ConstArg(inner) => self.emit_const_arg(inner).into(),
@@ -98,10 +94,7 @@ impl Translator {
         }
     }
 
-    pub(crate) fn emit_generic_param(
-        &mut self,
-        node: ast::GenericParam,
-    ) -> Label<generated::GenericParam> {
+    pub(crate) fn emit_generic_param(&mut self, node: ast::GenericParam) -> Label<generated::GenericParam> {
         match node {
             ast::GenericParam::ConstParam(inner) => self.emit_const_param(inner).into(),
             ast::GenericParam::LifetimeParam(inner) => self.emit_lifetime_param(inner).into(),
@@ -240,14 +233,8 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_assoc_item_list(
-        &mut self,
-        node: ast::AssocItemList,
-    ) -> Label<generated::AssocItemList> {
-        let assoc_items = node
-            .assoc_items()
-            .map(|x| self.emit_assoc_item(x))
-            .collect();
+    pub(crate) fn emit_assoc_item_list(&mut self, node: ast::AssocItemList) -> Label<generated::AssocItemList> {
+        let assoc_items = node.assoc_items().map(|x| self.emit_assoc_item(x)).collect();
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let label = self.trap.emit(generated::AssocItemList {
             id: TrapId::Star,
@@ -259,20 +246,13 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_assoc_type_arg(
-        &mut self,
-        node: ast::AssocTypeArg,
-    ) -> Label<generated::AssocTypeArg> {
+    pub(crate) fn emit_assoc_type_arg(&mut self, node: ast::AssocTypeArg) -> Label<generated::AssocTypeArg> {
         let const_arg = node.const_arg().map(|x| self.emit_const_arg(x));
-        let generic_arg_list = node
-            .generic_arg_list()
-            .map(|x| self.emit_generic_arg_list(x));
+        let generic_arg_list = node.generic_arg_list().map(|x| self.emit_generic_arg_list(x));
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
         let param_list = node.param_list().map(|x| self.emit_param_list(x));
         let ret_type = node.ret_type().map(|x| self.emit_ret_type(x));
-        let return_type_syntax = node
-            .return_type_syntax()
-            .map(|x| self.emit_return_type_syntax(x));
+        let return_type_syntax = node.return_type_syntax().map(|x| self.emit_return_type_syntax(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
         let label = self.trap.emit(generated::AssocTypeArg {
@@ -315,10 +295,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_become_expr(
-        &mut self,
-        node: ast::BecomeExpr,
-    ) -> Label<generated::BecomeExpr> {
+    pub(crate) fn emit_become_expr(&mut self, node: ast::BecomeExpr) -> Label<generated::BecomeExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let expr = node.expr().map(|x| self.emit_expr(x));
         let label = self.trap.emit(generated::BecomeExpr {
@@ -419,13 +396,8 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_closure_binder(
-        &mut self,
-        node: ast::ClosureBinder,
-    ) -> Label<generated::ClosureBinder> {
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+    pub(crate) fn emit_closure_binder(&mut self, node: ast::ClosureBinder) -> Label<generated::ClosureBinder> {
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let label = self.trap.emit(generated::ClosureBinder {
             id: TrapId::Star,
             generic_param_list,
@@ -435,10 +407,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_closure_expr(
-        &mut self,
-        node: ast::ClosureExpr,
-    ) -> Label<generated::ClosureExpr> {
+    pub(crate) fn emit_closure_expr(&mut self, node: ast::ClosureExpr) -> Label<generated::ClosureExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let body = node.body().map(|x| self.emit_expr(x));
         let closure_binder = node.closure_binder().map(|x| self.emit_closure_binder(x));
@@ -487,10 +456,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_const_block_pat(
-        &mut self,
-        node: ast::ConstBlockPat,
-    ) -> Label<generated::ConstBlockPat> {
+    pub(crate) fn emit_const_block_pat(&mut self, node: ast::ConstBlockPat) -> Label<generated::ConstBlockPat> {
         let block_expr = node.block_expr().map(|x| self.emit_block_expr(x));
         let label = self.trap.emit(generated::ConstBlockPat {
             id: TrapId::Star,
@@ -501,10 +467,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_const_param(
-        &mut self,
-        node: ast::ConstParam,
-    ) -> Label<generated::ConstParam> {
+    pub(crate) fn emit_const_param(&mut self, node: ast::ConstParam) -> Label<generated::ConstParam> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let default_val = node.default_val().map(|x| self.emit_const_arg(x));
         let name = node.name().map(|x| self.emit_name(x));
@@ -521,10 +484,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_continue_expr(
-        &mut self,
-        node: ast::ContinueExpr,
-    ) -> Label<generated::ContinueExpr> {
+    pub(crate) fn emit_continue_expr(&mut self, node: ast::ContinueExpr) -> Label<generated::ContinueExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let lifetime = node.lifetime().map(|x| self.emit_lifetime(x));
         let label = self.trap.emit(generated::ContinueExpr {
@@ -537,10 +497,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_dyn_trait_type(
-        &mut self,
-        node: ast::DynTraitType,
-    ) -> Label<generated::DynTraitType> {
+    pub(crate) fn emit_dyn_trait_type(&mut self, node: ast::DynTraitType) -> Label<generated::DynTraitType> {
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
         let label = self.trap.emit(generated::DynTraitType {
             id: TrapId::Star,
@@ -553,9 +510,7 @@ impl Translator {
 
     pub(crate) fn emit_enum(&mut self, node: ast::Enum) -> Label<generated::Enum> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let variant_list = node.variant_list().map(|x| self.emit_variant_list(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
@@ -585,15 +540,10 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_extern_block(
-        &mut self,
-        node: ast::ExternBlock,
-    ) -> Label<generated::ExternBlock> {
+    pub(crate) fn emit_extern_block(&mut self, node: ast::ExternBlock) -> Label<generated::ExternBlock> {
         let abi = node.abi().map(|x| self.emit_abi(x));
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let extern_item_list = node
-            .extern_item_list()
-            .map(|x| self.emit_extern_item_list(x));
+        let extern_item_list = node.extern_item_list().map(|x| self.emit_extern_item_list(x));
         let label = self.trap.emit(generated::ExternBlock {
             id: TrapId::Star,
             abi,
@@ -605,10 +555,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_extern_crate(
-        &mut self,
-        node: ast::ExternCrate,
-    ) -> Label<generated::ExternCrate> {
+    pub(crate) fn emit_extern_crate(&mut self, node: ast::ExternCrate) -> Label<generated::ExternCrate> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
         let rename = node.rename().map(|x| self.emit_rename(x));
@@ -625,15 +572,9 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_extern_item_list(
-        &mut self,
-        node: ast::ExternItemList,
-    ) -> Label<generated::ExternItemList> {
+    pub(crate) fn emit_extern_item_list(&mut self, node: ast::ExternItemList) -> Label<generated::ExternItemList> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let extern_items = node
-            .extern_items()
-            .map(|x| self.emit_extern_item(x))
-            .collect();
+        let extern_items = node.extern_items().map(|x| self.emit_extern_item(x)).collect();
         let label = self.trap.emit(generated::ExternItemList {
             id: TrapId::Star,
             attrs,
@@ -663,9 +604,7 @@ impl Translator {
         let abi = node.abi().map(|x| self.emit_abi(x));
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let body = node.body().map(|x| self.emit_block_expr(x));
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let param_list = node.param_list().map(|x| self.emit_param_list(x));
         let ret_type = node.ret_type().map(|x| self.emit_ret_type(x));
@@ -723,9 +662,7 @@ impl Translator {
     }
 
     pub(crate) fn emit_for_type(&mut self, node: ast::ForType) -> Label<generated::ForType> {
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let label = self.trap.emit(generated::ForType {
             id: TrapId::Star,
@@ -737,10 +674,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_format_args_arg(
-        &mut self,
-        node: ast::FormatArgsArg,
-    ) -> Label<generated::FormatArgsArg> {
+    pub(crate) fn emit_format_args_arg(&mut self, node: ast::FormatArgsArg) -> Label<generated::FormatArgsArg> {
         let expr = node.expr().map(|x| self.emit_expr(x));
         let name = node.name().map(|x| self.emit_name(x));
         let label = self.trap.emit(generated::FormatArgsArg {
@@ -753,10 +687,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_format_args_expr(
-        &mut self,
-        node: ast::FormatArgsExpr,
-    ) -> Label<generated::FormatArgsExpr> {
+    pub(crate) fn emit_format_args_expr(&mut self, node: ast::FormatArgsExpr) -> Label<generated::FormatArgsExpr> {
         let args = node.args().map(|x| self.emit_format_args_arg(x)).collect();
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let template = node.template().map(|x| self.emit_expr(x));
@@ -771,14 +702,8 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_generic_arg_list(
-        &mut self,
-        node: ast::GenericArgList,
-    ) -> Label<generated::GenericArgList> {
-        let generic_args = node
-            .generic_args()
-            .map(|x| self.emit_generic_arg(x))
-            .collect();
+    pub(crate) fn emit_generic_arg_list(&mut self, node: ast::GenericArgList) -> Label<generated::GenericArgList> {
+        let generic_args = node.generic_args().map(|x| self.emit_generic_arg(x)).collect();
         let label = self.trap.emit(generated::GenericArgList {
             id: TrapId::Star,
             generic_args,
@@ -788,14 +713,8 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_generic_param_list(
-        &mut self,
-        node: ast::GenericParamList,
-    ) -> Label<generated::GenericParamList> {
-        let generic_params = node
-            .generic_params()
-            .map(|x| self.emit_generic_param(x))
-            .collect();
+    pub(crate) fn emit_generic_param_list(&mut self, node: ast::GenericParamList) -> Label<generated::GenericParamList> {
+        let generic_params = node.generic_params().map(|x| self.emit_generic_param(x)).collect();
         let label = self.trap.emit(generated::GenericParamList {
             id: TrapId::Star,
             generic_params,
@@ -840,9 +759,7 @@ impl Translator {
     pub(crate) fn emit_impl(&mut self, node: ast::Impl) -> Label<generated::Impl> {
         let assoc_item_list = node.assoc_item_list().map(|x| self.emit_assoc_item_list(x));
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let self_ty = node.self_ty().map(|x| self.emit_type(x));
         let trait_ = node.trait_().map(|x| self.emit_type(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
@@ -862,10 +779,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_impl_trait_type(
-        &mut self,
-        node: ast::ImplTraitType,
-    ) -> Label<generated::ImplTraitType> {
+    pub(crate) fn emit_impl_trait_type(&mut self, node: ast::ImplTraitType) -> Label<generated::ImplTraitType> {
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
         let label = self.trap.emit(generated::ImplTraitType {
             id: TrapId::Star,
@@ -892,7 +806,9 @@ impl Translator {
     }
 
     pub(crate) fn emit_infer_type(&mut self, node: ast::InferType) -> Label<generated::InferType> {
-        let label = self.trap.emit(generated::InferType { id: TrapId::Star });
+        let label = self.trap.emit(generated::InferType {
+            id: TrapId::Star,
+        });
         self.emit_location(label, &node);
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
@@ -978,10 +894,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_lifetime_arg(
-        &mut self,
-        node: ast::LifetimeArg,
-    ) -> Label<generated::LifetimeArg> {
+    pub(crate) fn emit_lifetime_arg(&mut self, node: ast::LifetimeArg) -> Label<generated::LifetimeArg> {
         let lifetime = node.lifetime().map(|x| self.emit_lifetime(x));
         let label = self.trap.emit(generated::LifetimeArg {
             id: TrapId::Star,
@@ -992,10 +905,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_lifetime_param(
-        &mut self,
-        node: ast::LifetimeParam,
-    ) -> Label<generated::LifetimeParam> {
+    pub(crate) fn emit_lifetime_param(&mut self, node: ast::LifetimeParam) -> Label<generated::LifetimeParam> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let lifetime = node.lifetime().map(|x| self.emit_lifetime(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
@@ -1023,10 +933,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_literal_pat(
-        &mut self,
-        node: ast::LiteralPat,
-    ) -> Label<generated::LiteralPat> {
+    pub(crate) fn emit_literal_pat(&mut self, node: ast::LiteralPat) -> Label<generated::LiteralPat> {
         let literal = node.literal().map(|x| self.emit_literal(x));
         let label = self.trap.emit(generated::LiteralPat {
             id: TrapId::Star,
@@ -1108,10 +1015,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_macro_rules(
-        &mut self,
-        node: ast::MacroRules,
-    ) -> Label<generated::MacroRules> {
+    pub(crate) fn emit_macro_rules(&mut self, node: ast::MacroRules) -> Label<generated::MacroRules> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let name = node.name().map(|x| self.emit_name(x));
         let token_tree = node.token_tree().map(|x| self.emit_token_tree(x));
@@ -1156,10 +1060,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_match_arm_list(
-        &mut self,
-        node: ast::MatchArmList,
-    ) -> Label<generated::MatchArmList> {
+    pub(crate) fn emit_match_arm_list(&mut self, node: ast::MatchArmList) -> Label<generated::MatchArmList> {
         let arms = node.arms().map(|x| self.emit_match_arm(x)).collect();
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let label = self.trap.emit(generated::MatchArmList {
@@ -1187,10 +1088,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_match_guard(
-        &mut self,
-        node: ast::MatchGuard,
-    ) -> Label<generated::MatchGuard> {
+    pub(crate) fn emit_match_guard(&mut self, node: ast::MatchGuard) -> Label<generated::MatchGuard> {
         let condition = node.condition().map(|x| self.emit_expr(x));
         let label = self.trap.emit(generated::MatchGuard {
             id: TrapId::Star,
@@ -1216,15 +1114,10 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_method_call_expr(
-        &mut self,
-        node: ast::MethodCallExpr,
-    ) -> Label<generated::MethodCallExpr> {
+    pub(crate) fn emit_method_call_expr(&mut self, node: ast::MethodCallExpr) -> Label<generated::MethodCallExpr> {
         let arg_list = node.arg_list().map(|x| self.emit_arg_list(x));
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_arg_list = node
-            .generic_arg_list()
-            .map(|x| self.emit_generic_arg_list(x));
+        let generic_arg_list = node.generic_arg_list().map(|x| self.emit_generic_arg_list(x));
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
         let receiver = node.receiver().map(|x| self.emit_expr(x));
         let label = self.trap.emit(generated::MethodCallExpr {
@@ -1280,16 +1173,15 @@ impl Translator {
     }
 
     pub(crate) fn emit_never_type(&mut self, node: ast::NeverType) -> Label<generated::NeverType> {
-        let label = self.trap.emit(generated::NeverType { id: TrapId::Star });
+        let label = self.trap.emit(generated::NeverType {
+            id: TrapId::Star,
+        });
         self.emit_location(label, &node);
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
     }
 
-    pub(crate) fn emit_offset_of_expr(
-        &mut self,
-        node: ast::OffsetOfExpr,
-    ) -> Label<generated::OffsetOfExpr> {
+    pub(crate) fn emit_offset_of_expr(&mut self, node: ast::OffsetOfExpr) -> Label<generated::OffsetOfExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let fields = node.fields().map(|x| self.emit_name_ref(x)).collect();
         let ty = node.ty().map(|x| self.emit_type(x));
@@ -1415,20 +1307,13 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_path_segment(
-        &mut self,
-        node: ast::PathSegment,
-    ) -> Label<generated::PathSegment> {
-        let generic_arg_list = node
-            .generic_arg_list()
-            .map(|x| self.emit_generic_arg_list(x));
+    pub(crate) fn emit_path_segment(&mut self, node: ast::PathSegment) -> Label<generated::PathSegment> {
+        let generic_arg_list = node.generic_arg_list().map(|x| self.emit_generic_arg_list(x));
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
         let param_list = node.param_list().map(|x| self.emit_param_list(x));
         let path_type = node.path_type().map(|x| self.emit_path_type(x));
         let ret_type = node.ret_type().map(|x| self.emit_ret_type(x));
-        let return_type_syntax = node
-            .return_type_syntax()
-            .map(|x| self.emit_return_type_syntax(x));
+        let return_type_syntax = node.return_type_syntax().map(|x| self.emit_return_type_syntax(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let label = self.trap.emit(generated::PathSegment {
             id: TrapId::Star,
@@ -1456,10 +1341,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_prefix_expr(
-        &mut self,
-        node: ast::PrefixExpr,
-    ) -> Label<generated::PrefixExpr> {
+    pub(crate) fn emit_prefix_expr(&mut self, node: ast::PrefixExpr) -> Label<generated::PrefixExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let expr = node.expr().map(|x| self.emit_expr(x));
         let operator_name = node.try_get_text();
@@ -1517,14 +1399,9 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_expr(
-        &mut self,
-        node: ast::RecordExpr,
-    ) -> Label<generated::RecordExpr> {
+    pub(crate) fn emit_record_expr(&mut self, node: ast::RecordExpr) -> Label<generated::RecordExpr> {
         let path = node.path().map(|x| self.emit_path(x));
-        let record_expr_field_list = node
-            .record_expr_field_list()
-            .map(|x| self.emit_record_expr_field_list(x));
+        let record_expr_field_list = node.record_expr_field_list().map(|x| self.emit_record_expr_field_list(x));
         let label = self.trap.emit(generated::RecordExpr {
             id: TrapId::Star,
             path,
@@ -1535,10 +1412,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_expr_field(
-        &mut self,
-        node: ast::RecordExprField,
-    ) -> Label<generated::RecordExprField> {
+    pub(crate) fn emit_record_expr_field(&mut self, node: ast::RecordExprField) -> Label<generated::RecordExprField> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let expr = node.expr().map(|x| self.emit_expr(x));
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
@@ -1553,15 +1427,9 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_expr_field_list(
-        &mut self,
-        node: ast::RecordExprFieldList,
-    ) -> Label<generated::RecordExprFieldList> {
+    pub(crate) fn emit_record_expr_field_list(&mut self, node: ast::RecordExprFieldList) -> Label<generated::RecordExprFieldList> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let fields = node
-            .fields()
-            .map(|x| self.emit_record_expr_field(x))
-            .collect();
+        let fields = node.fields().map(|x| self.emit_record_expr_field(x)).collect();
         let spread = node.spread().map(|x| self.emit_expr(x));
         let label = self.trap.emit(generated::RecordExprFieldList {
             id: TrapId::Star,
@@ -1574,10 +1442,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_field(
-        &mut self,
-        node: ast::RecordField,
-    ) -> Label<generated::RecordField> {
+    pub(crate) fn emit_record_field(&mut self, node: ast::RecordField) -> Label<generated::RecordField> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let name = node.name().map(|x| self.emit_name(x));
         let ty = node.ty().map(|x| self.emit_type(x));
@@ -1594,10 +1459,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_field_list(
-        &mut self,
-        node: ast::RecordFieldList,
-    ) -> Label<generated::RecordFieldList> {
+    pub(crate) fn emit_record_field_list(&mut self, node: ast::RecordFieldList) -> Label<generated::RecordFieldList> {
         let fields = node.fields().map(|x| self.emit_record_field(x)).collect();
         let label = self.trap.emit(generated::RecordFieldList {
             id: TrapId::Star,
@@ -1610,9 +1472,7 @@ impl Translator {
 
     pub(crate) fn emit_record_pat(&mut self, node: ast::RecordPat) -> Label<generated::RecordPat> {
         let path = node.path().map(|x| self.emit_path(x));
-        let record_pat_field_list = node
-            .record_pat_field_list()
-            .map(|x| self.emit_record_pat_field_list(x));
+        let record_pat_field_list = node.record_pat_field_list().map(|x| self.emit_record_pat_field_list(x));
         let label = self.trap.emit(generated::RecordPat {
             id: TrapId::Star,
             path,
@@ -1623,10 +1483,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_pat_field(
-        &mut self,
-        node: ast::RecordPatField,
-    ) -> Label<generated::RecordPatField> {
+    pub(crate) fn emit_record_pat_field(&mut self, node: ast::RecordPatField) -> Label<generated::RecordPatField> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));
         let pat = node.pat().map(|x| self.emit_pat(x));
@@ -1641,14 +1498,8 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_record_pat_field_list(
-        &mut self,
-        node: ast::RecordPatFieldList,
-    ) -> Label<generated::RecordPatFieldList> {
-        let fields = node
-            .fields()
-            .map(|x| self.emit_record_pat_field(x))
-            .collect();
+    pub(crate) fn emit_record_pat_field_list(&mut self, node: ast::RecordPatFieldList) -> Label<generated::RecordPatFieldList> {
+        let fields = node.fields().map(|x| self.emit_record_pat_field(x)).collect();
         let rest_pat = node.rest_pat().map(|x| self.emit_rest_pat(x));
         let label = self.trap.emit(generated::RecordPatFieldList {
             id: TrapId::Star,
@@ -1730,10 +1581,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_return_expr(
-        &mut self,
-        node: ast::ReturnExpr,
-    ) -> Label<generated::ReturnExpr> {
+    pub(crate) fn emit_return_expr(&mut self, node: ast::ReturnExpr) -> Label<generated::ReturnExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let expr = node.expr().map(|x| self.emit_expr(x));
         let label = self.trap.emit(generated::ReturnExpr {
@@ -1746,13 +1594,10 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_return_type_syntax(
-        &mut self,
-        node: ast::ReturnTypeSyntax,
-    ) -> Label<generated::ReturnTypeSyntax> {
-        let label = self
-            .trap
-            .emit(generated::ReturnTypeSyntax { id: TrapId::Star });
+    pub(crate) fn emit_return_type_syntax(&mut self, node: ast::ReturnTypeSyntax) -> Label<generated::ReturnTypeSyntax> {
+        let label = self.trap.emit(generated::ReturnTypeSyntax {
+            id: TrapId::Star,
+        });
         self.emit_location(label, &node);
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
@@ -1797,10 +1642,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_source_file(
-        &mut self,
-        node: ast::SourceFile,
-    ) -> Label<generated::SourceFile> {
+    pub(crate) fn emit_source_file(&mut self, node: ast::SourceFile) -> Label<generated::SourceFile> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let items = node.items().map(|x| self.emit_item(x)).collect();
         let label = self.trap.emit(generated::SourceFile {
@@ -1850,9 +1692,7 @@ impl Translator {
     pub(crate) fn emit_struct(&mut self, node: ast::Struct) -> Label<generated::Struct> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let field_list = node.field_list().map(|x| self.emit_field_list(x));
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
         let where_clause = node.where_clause().map(|x| self.emit_where_clause(x));
@@ -1871,7 +1711,9 @@ impl Translator {
     }
 
     pub(crate) fn emit_token_tree(&mut self, node: ast::TokenTree) -> Label<generated::TokenTree> {
-        let label = self.trap.emit(generated::TokenTree { id: TrapId::Star });
+        let label = self.trap.emit(generated::TokenTree {
+            id: TrapId::Star,
+        });
         self.emit_location(label, &node);
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
@@ -1880,9 +1722,7 @@ impl Translator {
     pub(crate) fn emit_trait(&mut self, node: ast::Trait) -> Label<generated::Trait> {
         let assoc_item_list = node.assoc_item_list().map(|x| self.emit_assoc_item_list(x));
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
@@ -1902,14 +1742,9 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_trait_alias(
-        &mut self,
-        node: ast::TraitAlias,
-    ) -> Label<generated::TraitAlias> {
+    pub(crate) fn emit_trait_alias(&mut self, node: ast::TraitAlias) -> Label<generated::TraitAlias> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
@@ -1954,10 +1789,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_tuple_field(
-        &mut self,
-        node: ast::TupleField,
-    ) -> Label<generated::TupleField> {
+    pub(crate) fn emit_tuple_field(&mut self, node: ast::TupleField) -> Label<generated::TupleField> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let ty = node.ty().map(|x| self.emit_type(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
@@ -1972,10 +1804,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_tuple_field_list(
-        &mut self,
-        node: ast::TupleFieldList,
-    ) -> Label<generated::TupleFieldList> {
+    pub(crate) fn emit_tuple_field_list(&mut self, node: ast::TupleFieldList) -> Label<generated::TupleFieldList> {
         let fields = node.fields().map(|x| self.emit_tuple_field(x)).collect();
         let label = self.trap.emit(generated::TupleFieldList {
             id: TrapId::Star,
@@ -1997,10 +1826,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_tuple_struct_pat(
-        &mut self,
-        node: ast::TupleStructPat,
-    ) -> Label<generated::TupleStructPat> {
+    pub(crate) fn emit_tuple_struct_pat(&mut self, node: ast::TupleStructPat) -> Label<generated::TupleStructPat> {
         let fields = node.fields().map(|x| self.emit_pat(x)).collect();
         let path = node.path().map(|x| self.emit_path(x));
         let label = self.trap.emit(generated::TupleStructPat {
@@ -2026,9 +1852,7 @@ impl Translator {
 
     pub(crate) fn emit_type_alias(&mut self, node: ast::TypeAlias) -> Label<generated::TypeAlias> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
@@ -2061,9 +1885,7 @@ impl Translator {
     }
 
     pub(crate) fn emit_type_bound(&mut self, node: ast::TypeBound) -> Label<generated::TypeBound> {
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let lifetime = node.lifetime().map(|x| self.emit_lifetime(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let label = self.trap.emit(generated::TypeBound {
@@ -2077,10 +1899,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_type_bound_list(
-        &mut self,
-        node: ast::TypeBoundList,
-    ) -> Label<generated::TypeBoundList> {
+    pub(crate) fn emit_type_bound_list(&mut self, node: ast::TypeBoundList) -> Label<generated::TypeBoundList> {
         let bounds = node.bounds().map(|x| self.emit_type_bound(x)).collect();
         let label = self.trap.emit(generated::TypeBoundList {
             id: TrapId::Star,
@@ -2108,10 +1927,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_underscore_expr(
-        &mut self,
-        node: ast::UnderscoreExpr,
-    ) -> Label<generated::UnderscoreExpr> {
+    pub(crate) fn emit_underscore_expr(&mut self, node: ast::UnderscoreExpr) -> Label<generated::UnderscoreExpr> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
         let label = self.trap.emit(generated::UnderscoreExpr {
             id: TrapId::Star,
@@ -2124,13 +1940,9 @@ impl Translator {
 
     pub(crate) fn emit_union(&mut self, node: ast::Union) -> Label<generated::Union> {
         let attrs = node.attrs().map(|x| self.emit_attr(x)).collect();
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let name = node.name().map(|x| self.emit_name(x));
-        let record_field_list = node
-            .record_field_list()
-            .map(|x| self.emit_record_field_list(x));
+        let record_field_list = node.record_field_list().map(|x| self.emit_record_field_list(x));
         let visibility = node.visibility().map(|x| self.emit_visibility(x));
         let where_clause = node.where_clause().map(|x| self.emit_where_clause(x));
         let label = self.trap.emit(generated::Union {
@@ -2177,10 +1989,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_use_tree_list(
-        &mut self,
-        node: ast::UseTreeList,
-    ) -> Label<generated::UseTreeList> {
+    pub(crate) fn emit_use_tree_list(&mut self, node: ast::UseTreeList) -> Label<generated::UseTreeList> {
         let use_trees = node.use_trees().map(|x| self.emit_use_tree(x)).collect();
         let label = self.trap.emit(generated::UseTreeList {
             id: TrapId::Star,
@@ -2210,10 +2019,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_variant_list(
-        &mut self,
-        node: ast::VariantList,
-    ) -> Label<generated::VariantList> {
+    pub(crate) fn emit_variant_list(&mut self, node: ast::VariantList) -> Label<generated::VariantList> {
         let variants = node.variants().map(|x| self.emit_variant(x)).collect();
         let label = self.trap.emit(generated::VariantList {
             id: TrapId::Star,
@@ -2224,10 +2030,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_visibility(
-        &mut self,
-        node: ast::Visibility,
-    ) -> Label<generated::Visibility> {
+    pub(crate) fn emit_visibility(&mut self, node: ast::Visibility) -> Label<generated::Visibility> {
         let path = node.path().map(|x| self.emit_path(x));
         let label = self.trap.emit(generated::Visibility {
             id: TrapId::Star,
@@ -2238,10 +2041,7 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_where_clause(
-        &mut self,
-        node: ast::WhereClause,
-    ) -> Label<generated::WhereClause> {
+    pub(crate) fn emit_where_clause(&mut self, node: ast::WhereClause) -> Label<generated::WhereClause> {
         let predicates = node.predicates().map(|x| self.emit_where_pred(x)).collect();
         let label = self.trap.emit(generated::WhereClause {
             id: TrapId::Star,
@@ -2253,9 +2053,7 @@ impl Translator {
     }
 
     pub(crate) fn emit_where_pred(&mut self, node: ast::WherePred) -> Label<generated::WherePred> {
-        let generic_param_list = node
-            .generic_param_list()
-            .map(|x| self.emit_generic_param_list(x));
+        let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));
         let lifetime = node.lifetime().map(|x| self.emit_lifetime(x));
         let ty = node.ty().map(|x| self.emit_type(x));
         let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));
@@ -2288,11 +2086,10 @@ impl Translator {
         label
     }
 
-    pub(crate) fn emit_wildcard_pat(
-        &mut self,
-        node: ast::WildcardPat,
-    ) -> Label<generated::WildcardPat> {
-        let label = self.trap.emit(generated::WildcardPat { id: TrapId::Star });
+    pub(crate) fn emit_wildcard_pat(&mut self, node: ast::WildcardPat) -> Label<generated::WildcardPat> {
+        let label = self.trap.emit(generated::WildcardPat {
+            id: TrapId::Star,
+        });
         self.emit_location(label, &node);
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
@@ -2323,4 +2120,5 @@ impl Translator {
         self.emit_tokens(label.into(), node.syntax().children_with_tokens());
         label
     }
+
 }