mirror of
https://github.com/rust-lang/rust.git
synced 2025-04-30 20:17:50 +00:00
b1b9278851
This works for most of its call sites. This is nice, because `emit` very
much makes sense as a consuming operation -- indeed,
`DiagnosticBuilderState` exists to ensure no diagnostic is emitted
twice, but it uses runtime checks.
For the small number of call sites where a consuming emit doesn't work,
the commit adds `DiagnosticBuilder::emit_without_consuming`. (This will
be removed in subsequent commits.)
Likewise, `emit_unless` becomes consuming. And `delay_as_bug` becomes
consuming, while `delay_as_bug_without_consuming` is added (which will
also be removed in subsequent commits.)
All this requires significant changes to `DiagnosticBuilder`'s chaining
methods. Currently `DiagnosticBuilder` method chaining uses a
non-consuming `&mut self -> &mut Self` style, which allows chaining to
be used when the chain ends in `emit()`, like so:
```
struct_err(msg).span(span).emit();
```
But it doesn't work when producing a `DiagnosticBuilder` value,
requiring this:
```
let mut err = self.struct_err(msg);
err.span(span);
err
```
This style of chaining won't work with consuming `emit` though. For
that, we need to use to a `self -> Self` style. That also would allow
`DiagnosticBuilder` production to be chained, e.g.:
```
self.struct_err(msg).span(span)
```
However, removing the `&mut self -> &mut Self` style would require that
individual modifications of a `DiagnosticBuilder` go from this:
```
err.span(span);
```
to this:
```
err = err.span(span);
```
There are *many* such places. I have a high tolerance for tedious
refactorings, but even I gave up after a long time trying to convert
them all.
Instead, this commit has it both ways: the existing `&mut self -> Self`
chaining methods are kept, and new `self -> Self` chaining methods are
added, all of which have a `_mv` suffix (short for "move"). Changes to
the existing `forward!` macro lets this happen with very little
additional boilerplate code. I chose to add the suffix to the new
chaining methods rather than the existing ones, because the number of
changes required is much smaller that way.
This doubled chainging is a bit clumsy, but I think it is worthwhile
because it allows a *lot* of good things to subsequently happen. In this
commit, there are many `mut` qualifiers removed in places where
diagnostics are emitted without being modified. In subsequent commits:
- chaining can be used more, making the code more concise;
- more use of chaining also permits the removal of redundant diagnostic
APIs like `struct_err_with_code`, which can be replaced easily with
`struct_err` + `code_mv`;
- `emit_without_diagnostic` can be removed, which simplifies a lot of
machinery, removing the need for `DiagnosticBuilderState`.
106 lines
3.7 KiB
Rust
106 lines
3.7 KiB
Rust
//! Detecting usage of the `#[debugger_visualizer]` attribute.
|
|
|
|
use rustc_ast::Attribute;
|
|
use rustc_data_structures::sync::Lrc;
|
|
use rustc_expand::base::resolve_path;
|
|
use rustc_middle::{
|
|
middle::debugger_visualizer::{DebuggerVisualizerFile, DebuggerVisualizerType},
|
|
query::{LocalCrate, Providers},
|
|
ty::TyCtxt,
|
|
};
|
|
use rustc_session::Session;
|
|
use rustc_span::sym;
|
|
|
|
use crate::errors::{DebugVisualizerInvalid, DebugVisualizerUnreadable};
|
|
|
|
impl DebuggerVisualizerCollector<'_> {
|
|
fn check_for_debugger_visualizer(&mut self, attr: &Attribute) {
|
|
if attr.has_name(sym::debugger_visualizer) {
|
|
let Some(hints) = attr.meta_item_list() else {
|
|
self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
|
|
return;
|
|
};
|
|
|
|
let hint = if hints.len() == 1 {
|
|
&hints[0]
|
|
} else {
|
|
self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
|
|
return;
|
|
};
|
|
|
|
let Some(meta_item) = hint.meta_item() else {
|
|
self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
|
|
return;
|
|
};
|
|
|
|
let (visualizer_type, visualizer_path) =
|
|
match (meta_item.name_or_empty(), meta_item.value_str()) {
|
|
(sym::natvis_file, Some(value)) => (DebuggerVisualizerType::Natvis, value),
|
|
(sym::gdb_script_file, Some(value)) => {
|
|
(DebuggerVisualizerType::GdbPrettyPrinter, value)
|
|
}
|
|
(_, _) => {
|
|
self.sess.dcx().emit_err(DebugVisualizerInvalid { span: meta_item.span });
|
|
return;
|
|
}
|
|
};
|
|
|
|
let file =
|
|
match resolve_path(&self.sess.parse_sess, visualizer_path.as_str(), attr.span) {
|
|
Ok(file) => file,
|
|
Err(err) => {
|
|
err.emit();
|
|
return;
|
|
}
|
|
};
|
|
|
|
match std::fs::read(&file) {
|
|
Ok(contents) => {
|
|
self.visualizers.push(DebuggerVisualizerFile::new(
|
|
Lrc::from(contents),
|
|
visualizer_type,
|
|
file,
|
|
));
|
|
}
|
|
Err(error) => {
|
|
self.sess.dcx().emit_err(DebugVisualizerUnreadable {
|
|
span: meta_item.span,
|
|
file: &file,
|
|
error,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct DebuggerVisualizerCollector<'a> {
|
|
sess: &'a Session,
|
|
visualizers: Vec<DebuggerVisualizerFile>,
|
|
}
|
|
|
|
impl<'ast> rustc_ast::visit::Visitor<'ast> for DebuggerVisualizerCollector<'_> {
|
|
fn visit_attribute(&mut self, attr: &'ast Attribute) {
|
|
self.check_for_debugger_visualizer(attr);
|
|
rustc_ast::visit::walk_attribute(self, attr);
|
|
}
|
|
}
|
|
|
|
/// Traverses and collects the debugger visualizers for a specific crate.
|
|
fn debugger_visualizers(tcx: TyCtxt<'_>, _: LocalCrate) -> Vec<DebuggerVisualizerFile> {
|
|
let resolver_and_krate = tcx.resolver_for_lowering(()).borrow();
|
|
let krate = &*resolver_and_krate.1;
|
|
|
|
let mut visitor = DebuggerVisualizerCollector { sess: tcx.sess, visualizers: Vec::new() };
|
|
rustc_ast::visit::Visitor::visit_crate(&mut visitor, krate);
|
|
|
|
// We are collecting visualizers in AST-order, which is deterministic,
|
|
// so we don't need to do any explicit sorting in order to get a
|
|
// deterministic query result
|
|
visitor.visualizers
|
|
}
|
|
|
|
pub fn provide(providers: &mut Providers) {
|
|
providers.debugger_visualizers = debugger_visualizers;
|
|
}
|