Skip to content

Replace field accesses in bindings generation with getters/setters on the Rust IR struct. #1326

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
copybara-service wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Replace field accesses in bindings generation with getters/setters on the Rust IR struct. #1326

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 4 additions & 4 deletions rs_bindings_from_cc/generate_bindings/cpp_type_name.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@ pub fn cpp_tagless_type_name_for_record(
record: &Record,
db: &BindingsGenerator<'_>,
) -> Result<TokenStream> {
let ident = expect_format_cc_type_name(record.cc_name.identifier.as_ref());
let ident = expect_format_cc_type_name(record.cc_name().as_str());
let namespace_qualifier = db.namespace_qualifier(record).format_for_cc()?;
Ok(quote! { #namespace_qualifier #ident })
}
Expand Down Expand Up @@ -151,18 +151,18 @@ pub fn tagless_cpp_type_name_for_item(
) -> Result<TokenStream> {
match item {
Item::IncompleteRecord(incomplete_record) => {
let ident = expect_format_cc_type_name(incomplete_record.cc_name.identifier.as_ref());
let ident = expect_format_cc_type_name(incomplete_record.cc_name().as_str());
let namespace_qualifier = db.namespace_qualifier(incomplete_record).format_for_cc()?;
Ok(quote! { #namespace_qualifier #ident })
}
Item::Record(record) => cpp_tagless_type_name_for_record(record, db),
Item::Enum(enum_) => {
let ident = expect_format_cc_type_name(&enum_.rs_name.identifier);
let ident = expect_format_cc_type_name(enum_.rs_name().as_str());
let namespace_qualifier = db.namespace_qualifier(item).format_for_cc()?;
Ok(quote! { #namespace_qualifier #ident })
}
Item::TypeAlias(type_alias) => {
let ident = expect_format_cc_type_name(&type_alias.cc_name.identifier);
let ident = expect_format_cc_type_name(type_alias.cc_name().as_str());
let namespace_qualifier = db.namespace_qualifier(item).format_for_cc()?;
Ok(quote! { #namespace_qualifier #ident })
}
Expand Down
6 changes: 3 additions & 3 deletions rs_bindings_from_cc/generate_bindings/database/code_snippet.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -221,11 +221,11 @@ pub fn missing_feature_descriptions(db: &BindingsGenerator, item: &Item) -> Resu
if func.is_noreturn {
missing_features.push("[[noreturn]] attribute".to_string());
}
for param in &func.params {
for param in func.params() {
if let Some(unknown_attr) = &param.unknown_attr {
missing_features.push(format!(
"crubit.rs/errors/unknown_attribute: param {param} has unknown attribute(s): {unknown_attr}",
param = &param.identifier.identifier
param = param.identifier().as_str()
));
}
}
Expand Down Expand Up @@ -803,7 +803,7 @@ pub fn generated_items_to_tokens<'db>(
let canonical_namespace: &Rc<ir::Namespace> = db
.find_decl(current_namespace.canonical_namespace_id)
.unwrap_or_else(|_| panic!("Namespace canonical_namespace_id {:?} not found as a valid Namespace item.", current_namespace.canonical_namespace_id));
let name = make_rs_ident(&canonical_namespace.rs_name.identifier);
let name = make_rs_ident(canonical_namespace.rs_name().as_str());

quote! {
#deprecated_attr
Expand Down
41 changes: 21 additions & 20 deletions rs_bindings_from_cc/generate_bindings/database/db.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -260,13 +260,11 @@ impl<'db> BindingsGenerator<'db> {
if let Some(parent_id) = f.enclosing_item_id
&& let Ok(record) = self.find_decl::<std::rc::Rc<ir::Record>>(parent_id)
{
return self.defining_target(record.id);
return self.defining_target(record.id());
}
None
}
ir::Item::Record(r) => {
r.template_specialization.as_ref().map(|ts| ts.defining_target.clone())
}
ir::Item::Record(r) => r.template_specialization().map(|ts| ts.defining_target.clone()),
ir::Item::UnsupportedItem(ui) => ui.defining_target.clone(),
_ => None,
}
Expand All @@ -286,9 +284,11 @@ impl<'db> BindingsGenerator<'db> {
ir::Item::ExistingRustType(existing_rust_type) => {
Some(existing_rust_type.cc_name.clone())
}
ir::Item::Record(record) => Some(record.cc_name.identifier.clone()),
ir::Item::Record(record) => {
Some(std::rc::Rc::from(record.cc_name().as_str()))
}
ir::Item::IncompleteRecord(record) => {
Some(record.cc_name.identifier.clone())
Some(std::rc::Rc::from(record.cc_name().as_str()))
}
_ => None,
}
Expand All @@ -298,7 +298,7 @@ impl<'db> BindingsGenerator<'db> {
};
match &f.cc_name {
ir::UnqualifiedIdentifier::Identifier(id) => {
name.push_str(&id.identifier);
name.push_str(id.as_str());
}
ir::UnqualifiedIdentifier::Operator(op) => {
name.push_str(&op.cc_name());
Expand Down Expand Up @@ -328,17 +328,17 @@ impl<'db> BindingsGenerator<'db> {
.into()
}
ir::Item::UseMod(u) => {
return format!("<[internal] use mod {}::* = {}>", u.mod_name, u.path).into()
return format!("<[internal] use mod {}::* = {}>", u.mod_name(), u.path).into()
}
ir::Item::UnsupportedItem(ui) => return ui.name.clone(),
ir::Item::ExistingRustType(e) => (e.id, e.cc_name.clone()),
ir::Item::Namespace(n) => (n.id, n.cc_name.identifier.clone()),
ir::Item::IncompleteRecord(r) => (r.id, r.cc_name.identifier.clone()),
ir::Item::Record(r) => (r.id, r.cc_name.identifier.clone()),
ir::Item::Enum(e) => (e.id, e.cc_name.identifier.clone()),
ir::Item::Constant(c) => (c.id, c.cc_name.identifier.clone()),
ir::Item::GlobalVar(g) => (g.id, g.cc_name.identifier.clone()),
ir::Item::TypeAlias(t) => (t.id, t.cc_name.identifier.clone()),
ir::Item::Namespace(n) => (n.id, std::rc::Rc::from(n.cc_name().as_str())),
ir::Item::IncompleteRecord(r) => (r.id, std::rc::Rc::from(r.cc_name().as_str())),
ir::Item::Record(r) => (r.id(), std::rc::Rc::from(r.cc_name().as_str())),
ir::Item::Enum(e) => (e.id, std::rc::Rc::from(e.cc_name().as_str())),
ir::Item::Constant(c) => (c.id, std::rc::Rc::from(c.cc_name().as_str())),
ir::Item::GlobalVar(g) => (g.id, std::rc::Rc::from(g.cc_name().as_str())),
ir::Item::TypeAlias(t) => (t.id, std::rc::Rc::from(t.cc_name().as_str())),
};
let qualifier = self.namespace_qualifier_from_id(id).format_for_cc_debug();
return format! {"{qualifier}{name}"}.into();
Expand Down Expand Up @@ -540,7 +540,7 @@ impl<'db> BindingsGenerator<'db> {
while let Some(parent_id) = enclosing_item_id {
match self.find_untyped_decl(parent_id) {
ir::Item::Namespace(ns) => {
namespaces.push(ns.rs_name.identifier.clone());
namespaces.push(std::rc::Rc::from(ns.rs_name().as_str()));
enclosing_item_id = ns.enclosing_item_id;
}
ir::Item::Record(parent_record) => {
Expand All @@ -552,9 +552,9 @@ impl<'db> BindingsGenerator<'db> {
self.record_to_associated_module_name(parent_record.clone()).unwrap();
nested_records.push((
module_name.to_string().into(),
parent_record.cc_name.identifier.clone(),
std::rc::Rc::from(parent_record.cc_name().as_str()),
));
enclosing_item_id = parent_record.enclosing_item_id;
enclosing_item_id = parent_record.enclosing_item_id();
}
ir::Item::ExistingRustType(rust_type) => {
assert!(
Expand Down Expand Up @@ -590,7 +590,8 @@ impl<'db> BindingsGenerator<'db> {
&self,
record: Rc<Record>,
) -> Result<proc_macro2::Ident> {
let record_name: &str = record.rs_name.as_str();
let rs_name = record.rs_name();
let record_name: &str = rs_name.as_str();
let snake_case_name = record_name.to_snake_case();
// Add an `_items` suffix to distinguish the module name if the record name is already snake-case,
// then distinguish by adding `_` suffixes until we find a name that is not in use.
Expand All @@ -603,7 +604,7 @@ impl<'db> BindingsGenerator<'db> {
let resolved_names = self.resolve_names(record.clone())?;
let is_used = |n: &str| match resolved_names.get(n) {
Some(ResolvedName::RecordNestedItems { parent_records_that_map_to_this_name }) => {
!parent_records_that_map_to_this_name.contains(&record.id)
!parent_records_that_map_to_this_name.contains(&record.id())
}
Some(_) => true,
None => false,
Expand Down
Loading
Loading