squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

generate set_arg code inside generate_field_attrs_code

Browse source
This commit is contained in:
Christian Poveda 2022-05-18 10:50:59 -05:00
parent 462c1c846b
commit 19e1f73085
No known key found for this signature in database
GPG key ID: 27525EF5E7420A50
1 changed files with 99 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

196
compiler/rustc_macros/src/diagnostics/diagnostic.rs
View file

@ -71,91 +71,72 @@ impl<'a> SessionDiagnosticDerive<'a> {
} }
}; };
// Keep track of which fields are subdiagnostics // Keep track of which fields are subdiagnostics or have no attributes.
let mut subdiagnostics = std::collections::HashSet::new(); let mut subdiagnostics_or_empty = std::collections::HashSet::new();
// Generates calls to `span_label` and similar functions based on the attributes // Generates calls to `span_label` and similar functions based on the attributes
// on fields. Code for suggestions uses formatting machinery and the value of // on fields. Code for suggestions uses formatting machinery and the value of
// other fields - because any given field can be referenced multiple times, it // other fields - because any given field can be referenced multiple times, it
// should be accessed through a borrow. When passing fields to `set_arg` (which // should be accessed through a borrow. When passing fields to `add_subdiagnostic`
// happens below) for Fluent, we want to move the data, so that has to happen // or `set_arg` (which happens below) for Fluent, we want to move the data, so that
// in a separate pass over the fields. // has to happen in a separate pass over the fields.
let attrs = structure let attrs = structure
.clone() .clone()
// Remove the fields that have a `subdiagnostic` attribute.
.filter(|field_binding| { .filter(|field_binding| {
field_binding.ast().attrs.iter().all(|attr| { let attrs = &field_binding.ast().attrs;
"subdiagnostic" != attr.path.segments.last().unwrap().ident.to_string()
|| { (!attrs.is_empty()
subdiagnostics.insert(field_binding.binding.clone()); && attrs.iter().all(|attr| {
false "subdiagnostic"
} != attr.path.segments.last().unwrap().ident.to_string()
}) }))
|| {
subdiagnostics_or_empty.insert(field_binding.binding.clone());
false
}
}) })
.each(|field_binding| { .each(|field_binding| {
let field = field_binding.ast(); let field = field_binding.ast();
let result = field.attrs.iter().map(|attr| { let field_span = field.span();
builder
.generate_field_attr_code(
attr,
FieldInfo {
vis: &field.vis,
binding: field_binding,
ty: &field.ty,
span: &field.span(),
},
)
.unwrap_or_else(|v| v.to_compile_error())
});
quote! { #(#result);* } builder.generate_field_attrs_code(
&field.attrs,
FieldInfo {
vis: &field.vis,
binding: field_binding,
ty: &field.ty,
span: &field_span,
},
)
}); });
// When generating `set_arg` calls, move data rather than borrow it to avoid // When generating `set_arg` or `add_subdiagnostic` calls, move data rather than
// requiring clones - this must therefore be the last use of each field (for // borrow it to avoid requiring clones - this must therefore be the last use of
// example, any formatting machinery that might refer to a field should be // each field (for example, any formatting machinery that might refer to a field
// generated already). // should be generated already).
structure.bind_with(|_| synstructure::BindStyle::Move); structure.bind_with(|_| synstructure::BindStyle::Move);
let args = structure.each(|field_binding| { // When a field has attributes like `#[label]` or `#[note]` then it doesn't
let field = field_binding.ast(); // need to be passed as an argument to the diagnostic. But when a field has no
// When a field has attributes like `#[label]` or `#[note]` then it doesn't // attributes or a `#[subdiagnostic]` attribute then it must be passed as an
// need to be passed as an argument to the diagnostic. But when a field has no // argument to the diagnostic so that it can be referred to by Fluent messages.
// attributes then it must be passed as an argument to the diagnostic so that let args = structure
// it can be referred to by Fluent messages. .filter(|field_binding| {
let tokens = if field.attrs.is_empty() { subdiagnostics_or_empty.contains(&field_binding.binding)
let diag = &builder.diag; })
let ident = field_binding.ast().ident.as_ref().unwrap(); .each(|field_binding| {
quote! { let field = field_binding.ast();
#diag.set_arg( let field_span = field.span();
stringify!(#ident),
#field_binding
);
}
} else {
quote! {}
};
// If this field had a subdiagnostic attribute, we generate the code here to
// avoid binding it twice.
if subdiagnostics.contains(&field_binding.binding) {
let result = field.attrs.iter().map(|attr| {
builder
.generate_field_attr_code(
attr,
FieldInfo {
vis: &field.vis,
binding: field_binding,
ty: &field.ty,
span: &field.span(),
},
)
.unwrap_or_else(|v| v.to_compile_error())
});
quote! { #(#result);* #tokens } builder.generate_field_attrs_code(
} else { &field.attrs,
tokens FieldInfo {
} vis: &field.vis,
}); binding: field_binding,
ty: &field.ty,
span: &field_span,
},
)
});
let span = ast.span().unwrap(); let span = ast.span().unwrap();
let (diag, sess) = (&builder.diag, &builder.sess); let (diag, sess) = (&builder.diag, &builder.sess);
@ -383,38 +364,59 @@ impl SessionDiagnosticDeriveBuilder {
Ok(tokens.drain(..).collect()) Ok(tokens.drain(..).collect())
} }
fn generate_field_attr_code( fn generate_field_attrs_code<'a>(
&mut self, &'a mut self,
attr: &syn::Attribute, attrs: &'a [syn::Attribute],
info: FieldInfo<'_>, info: FieldInfo<'a>,
) -> Result<TokenStream, SessionDiagnosticDeriveError> { ) -> TokenStream {
let field_binding = &info.binding.binding; let field_binding = &info.binding.binding;
let inner_ty = FieldInnerTy::from_type(&info.ty); let inner_ty = FieldInnerTy::from_type(&info.ty);
let name = attr.path.segments.last().unwrap().ident.to_string();
let (binding, needs_destructure) = match (name.as_str(), &inner_ty) {
// `primary_span` can accept a `Vec<Span>` so don't destructure that.
("primary_span", FieldInnerTy::Vec(_)) => (quote! { #field_binding.clone() }, false),
// `subdiagnostics` are not derefed because they are bound by value.
("subdiagnostic", _) => (quote! { #field_binding }, true),
_ => (quote! { *#field_binding }, true),
};
let generated_code = self.generate_inner_field_code( if attrs.is_empty() {
attr, let diag = &self.diag;
FieldInfo { let ident = info.binding.ast().ident.as_ref().unwrap();
vis: info.vis, quote! {
binding: info.binding, #diag.set_arg(
ty: inner_ty.inner_type().unwrap_or(&info.ty), stringify!(#ident),
span: info.span, #field_binding
}, );
binding, }
)?;
if needs_destructure {
Ok(inner_ty.with(field_binding, generated_code))
} else { } else {
Ok(generated_code) attrs
.iter()
.map(move |attr| {
let name = attr.path.segments.last().unwrap().ident.to_string();
let (binding, needs_destructure) = match (name.as_str(), &inner_ty) {
// `primary_span` can accept a `Vec<Span>` so don't destructure that.
("primary_span", FieldInnerTy::Vec(_)) => {
(quote! { #field_binding.clone() }, false)
}
// `subdiagnostics` are not derefed because they are bound by value.
("subdiagnostic", _) => (quote! { #field_binding }, true),
_ => (quote! { *#field_binding }, true),
};
let generated_code = self
.generate_inner_field_code(
attr,
FieldInfo {
vis: info.vis,
binding: info.binding,
ty: inner_ty.inner_type().unwrap_or(&info.ty),
span: info.span,
},
binding,
)
.unwrap_or_else(|v| v.to_compile_error());
if needs_destructure {
inner_ty.with(field_binding, generated_code)
} else {
generated_code
}
})
.collect()
} }
} }