2019-09-06 23:41:54 +03:00
|
|
|
//! Attributes injected into the crate root from command line using `-Z crate-attr`.
|
|
|
|
|
2023-06-21 19:01:53 +08:00
|
|
|
use crate::errors;
|
2020-02-29 20:37:32 +03:00
|
|
|
use rustc_ast::attr::mk_attr;
|
|
|
|
use rustc_ast::token;
|
2020-04-27 23:26:11 +05:30
|
|
|
use rustc_ast::{self as ast, AttrItem, AttrStyle};
|
2020-01-11 15:03:15 +01:00
|
|
|
use rustc_session::parse::ParseSess;
|
2019-12-31 20:15:40 +03:00
|
|
|
use rustc_span::FileName;
|
2019-09-06 23:41:54 +03:00
|
|
|
|
2023-02-18 16:23:57 +04:00
|
|
|
pub fn inject(krate: &mut ast::Crate, parse_sess: &ParseSess, attrs: &[String]) {
|
2019-09-06 23:41:54 +03:00
|
|
|
for raw_attr in attrs {
|
2019-10-15 22:48:13 +02:00
|
|
|
let mut parser = rustc_parse::new_parser_from_source_str(
|
2019-09-06 23:41:54 +03:00
|
|
|
parse_sess,
|
2023-11-21 20:07:32 +01:00
|
|
|
FileName::cli_crate_attr_source_code(raw_attr),
|
2019-09-06 23:41:54 +03:00
|
|
|
raw_attr.clone(),
|
|
|
|
);
|
|
|
|
|
|
|
|
let start_span = parser.token.span;
|
2020-09-26 19:33:42 -04:00
|
|
|
let AttrItem { path, args, tokens: _ } = match parser.parse_attr_item(false) {
|
2020-03-17 08:59:56 +01:00
|
|
|
Ok(ai) => ai,
|
Make `DiagnosticBuilder::emit` consuming.
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`.
2024-01-03 12:17:35 +11:00
|
|
|
Err(err) => {
|
2020-03-17 08:59:56 +01:00
|
|
|
err.emit();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
};
|
2019-09-06 23:41:54 +03:00
|
|
|
let end_span = parser.token.span;
|
|
|
|
if parser.token != token::Eof {
|
2023-12-17 22:25:47 +11:00
|
|
|
parse_sess.dcx.emit_err(errors::InvalidCrateAttr { span: start_span.to(end_span) });
|
2019-09-06 23:41:54 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:29:40 +08:00
|
|
|
krate.attrs.push(mk_attr(
|
|
|
|
&parse_sess.attr_id_generator,
|
|
|
|
AttrStyle::Inner,
|
|
|
|
path,
|
|
|
|
args,
|
|
|
|
start_span.to(end_span),
|
|
|
|
));
|
2019-09-06 23:41:54 +03:00
|
|
|
}
|
|
|
|
}
|