use rustc_attr::{self as attr, Deprecation, Stability};
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::sync::{self, Lrc};
-use rustc_errors::{Applicability, DiagnosticBuilder, ErrorReported};
+use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed};
use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT;
use rustc_lint_defs::BuiltinLintDiagnostics;
use rustc_parse::{self, nt_to_tokenstream, parser, MACRO_ARGUMENTS};
use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId};
use rustc_span::source_map::SourceMap;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{FileName, MultiSpan, Span, DUMMY_SP};
+use rustc_span::{MultiSpan, Span, DUMMY_SP};
use smallvec::{smallvec, SmallVec};
use std::default::Default;
Annotatable::Param(ref p) => p.span,
Annotatable::FieldDef(ref sf) => sf.span,
Annotatable::Variant(ref v) => v.span,
- Annotatable::Crate(ref c) => c.span,
+ Annotatable::Crate(ref c) => c.spans.inner_span,
}
}
ecx: &'cx mut ExtCtxt<'_>,
span: Span,
ts: TokenStream,
- ) -> Result<TokenStream, ErrorReported>;
+ ) -> Result<TokenStream, ErrorGuaranteed>;
}
impl<F> ProcMacro for F
_ecx: &'cx mut ExtCtxt<'_>,
_span: Span,
ts: TokenStream,
- ) -> Result<TokenStream, ErrorReported> {
+ ) -> Result<TokenStream, ErrorGuaranteed> {
// FIXME setup implicit context in TLS before calling self.
Ok(self(ts))
}
span: Span,
annotation: TokenStream,
annotated: TokenStream,
- ) -> Result<TokenStream, ErrorReported>;
+ ) -> Result<TokenStream, ErrorGuaranteed>;
}
impl<F> AttrProcMacro for F
_span: Span,
annotation: TokenStream,
annotated: TokenStream,
- ) -> Result<TokenStream, ErrorReported> {
+ ) -> Result<TokenStream, ErrorGuaranteed> {
// FIXME setup implicit context in TLS before calling self.
Ok(self(annotation, annotated))
}
self.current_expansion.id.expansion_cause()
}
- pub fn struct_span_err<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> DiagnosticBuilder<'a> {
+ pub fn struct_span_err<S: Into<MultiSpan>>(
+ &self,
+ sp: S,
+ msg: &str,
+ ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
self.sess.parse_sess.span_diagnostic.struct_span_err(sp, msg)
}
pub fn check_unused_macros(&mut self) {
self.resolver.check_unused_macros();
}
-
- /// Resolves a `path` mentioned inside Rust code, returning an absolute path.
- ///
- /// This unifies the logic used for resolving `include_X!`.
- ///
- /// FIXME: move this to `rustc_builtin_macros` and make it private.
- pub fn resolve_path(
- &self,
- path: impl Into<PathBuf>,
- span: Span,
- ) -> Result<PathBuf, DiagnosticBuilder<'a>> {
- let path = path.into();
-
- // Relative paths are resolved relative to the file in which they are found
- // after macro expansion (that is, they are unhygienic).
- if !path.is_absolute() {
- let callsite = span.source_callsite();
- let mut result = match self.source_map().span_to_filename(callsite) {
- FileName::Real(name) => name
- .into_local_path()
- .expect("attempting to resolve a file path in an external file"),
- FileName::DocTest(path, _) => path,
- other => {
- return Err(self.struct_span_err(
- span,
- &format!(
- "cannot resolve relative path in non-file source `{}`",
- self.source_map().filename_for_diagnostics(&other)
- ),
- ));
- }
- };
- result.pop();
- result.push(path);
- Ok(result)
- } else {
- Ok(path)
- }
- }
}
/// Extracts a string literal from the macro expanded version of `expr`,
cx: &'a mut ExtCtxt<'_>,
expr: P<ast::Expr>,
err_msg: &str,
-) -> Result<(Symbol, ast::StrStyle, Span), Option<(DiagnosticBuilder<'a>, bool)>> {
+) -> Result<(Symbol, ast::StrStyle, Span), Option<(DiagnosticBuilder<'a, ErrorGuaranteed>, bool)>> {
// Perform eager expansion on the expression.
// We want to be able to handle e.g., `concat!("foo", "bar")`.
let expr = cx.expander().fully_expand_fragment(AstFragment::Expr(expr)).make_expr();
pub fn parse_expr(p: &mut parser::Parser<'_>) -> Option<P<ast::Expr>> {
match p.parse_expr() {
Ok(e) => return Some(e),
- Err(mut err) => err.emit(),
+ Err(mut err) => {
+ err.emit();
+ }
}
while p.token != token::Eof {
p.bump();
// Once we've located the `#[proc_macro_derive]` attribute, verify
// that it's of the form `#[proc_macro_derive(Foo)]` or
// `#[proc_macro_derive(Foo, attributes(A, ..))]`
- let list = match attr.meta_item_list() {
- Some(list) => list,
- None => return None,
+ let Some(list) = attr.meta_item_list() else {
+ return None;
};
if list.len() != 1 && list.len() != 2 {
diag.span_err(attr.span, "attribute must have either one or two arguments");
return None;
}
- let trait_attr = match list[0].meta_item() {
- Some(meta_item) => meta_item,
- _ => {
- diag.span_err(list[0].span(), "not a meta item");
- return None;
- }
+ let Some(trait_attr) = list[0].meta_item() else {
+ diag.span_err(list[0].span(), "not a meta item");
+ return None;
};
let trait_ident = match trait_attr.ident() {
Some(trait_ident) if trait_attr.is_word() => trait_ident,
let attributes_attr = list.get(1);
let proc_attrs: Vec<_> = if let Some(attr) = attributes_attr {
if !attr.has_name(sym::attributes) {
- diag.span_err(attr.span(), "second argument must be `attributes`")
+ diag.span_err(attr.span(), "second argument must be `attributes`");
}
attr.meta_item_list()
.unwrap_or_else(|| {
})
.iter()
.filter_map(|attr| {
- let attr = match attr.meta_item() {
- Some(meta_item) => meta_item,
- _ => {
- diag.span_err(attr.span(), "not a meta item");
- return None;
- }
+ let Some(attr) = attr.meta_item() else {
+ diag.span_err(attr.span(), "not a meta item");
+ return None;
};
let ident = match attr.ident() {
projects / rustc.git / blobdiff