hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2025-12-16 16:53:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Rust: integrate rust code generation into //rust/codegen

Browse Source
This commit is contained in:
Paolo Tranquilli
2024-10-08 10:37:53 +02:00
parent 96dda8808c
commit 61c3aa6288
6 changed files with 148 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
rust/ast-generator/BUILD.bazel
View File

@@ -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__"],
)

2
rust/ast-generator/src/codegen.rs
View File

@@ -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()));
}

24
rust/ast-generator/src/main.rs
View File

@@ -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,

24
rust/codegen/BUILD.bazel
View File

@@ -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",
],
)

13
rust/codegen/codegen.sh Executable file
View File

@@ -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"

396
rust/extractor/src/translate/generated.rs generated
View File

@@ -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
}
}