use crate::base::ExtCtxt;

use crate::errors::{

CountRepetitionMisplaced, MetaVarExprUnrecognizedVar, MetaVarsDifSeqMatchers, MustRepeatOnce,

NoSyntaxVarsExprRepeat, VarStillRepeating,

use rustc_ast::token::{self, Delimiter, Token, TokenKind};

use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};

use rustc_data_structures::fx::FxHashMap;

use rustc_errors::{pluralize, Diag, PResult};

use rustc_errors::{pluralize, Diag, DiagCtxt, PResult};

use rustc_parse::parser::ParseNtResult;

use rustc_span::hygiene::{LocalExpnId, Transparency};

use rustc_span::symbol::{sym, Ident, MacroRulesNormalizedIdent};

use rustc_span::{with_metavar_spans, Span, SyntaxContext};

use rustc_session::parse::ParseSess;

use smallvec::{smallvec, SmallVec};

use std::mem;

///

/// Along the way, we do some additional error checking.

pub(super) fn transcribe<'a>(

cx: &ExtCtxt<'a>,

psess: &'a ParseSess,

interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,

src: &mbe::Delimited,

src_span: DelimSpan,

transparency: Transparency,

expand_id: LocalExpnId,

) -> PResult<'a, TokenStream> {

// Nothing for us to transcribe...

if src.tts.is_empty() {

// again, and we are done transcribing.

let mut result: Vec<TokenTree> = Vec::new();

let mut result_stack = Vec::new();

let mut marker = Marker(cx.current_expansion.id, transparency, Default::default());

let mut marker = Marker(expand_id, transparency, Default::default());

let dcx = &psess.dcx;

loop {

// Look at the last frame on the stack.

// If it still has a TokenTree we have not looked at yet, use that tree.

seq @ mbe::TokenTree::Sequence(_, seq_rep) => {

match lockstep_iter_size(seq, interp, &repeats) {

LockstepIterSize::Unconstrained => {

return Err(cx

.dcx()

.create_err(NoSyntaxVarsExprRepeat { span: seq.span() }));

return Err(dcx.create_err(NoSyntaxVarsExprRepeat { span: seq.span() }));

}

LockstepIterSize::Contradiction(msg) => {

// FIXME: this really ought to be caught at macro definition time... It

// happens when two meta-variables are used in the same repetition in a

// sequence, but they come from different sequence matchers and repeat

// different amounts.

return Err(cx

.dcx()

.create_err(MetaVarsDifSeqMatchers { span: seq.span(), msg }));

return Err(

dcx.create_err(MetaVarsDifSeqMatchers { span: seq.span(), msg })

);

}

LockstepIterSize::Constraint(len, _) => {

// FIXME: this really ought to be caught at macro definition

// time... It happens when the Kleene operator in the matcher and

// the body for the same meta-variable do not match.

return Err(cx

.dcx()

.create_err(MustRepeatOnce { span: sp.entire() }));

return Err(dcx.create_err(MustRepeatOnce { span: sp.entire() }));

}

} else {

// 0 is the initial counter (we have done 0 repetitions so far). `len`

MatchedSingle(ParseNtResult::Tt(tt)) => {

// `tt`s are emitted into the output stream directly as "raw tokens",

// without wrapping them into groups.

maybe_use_metavar_location(cx, &stack, sp, tt, &mut marker)

maybe_use_metavar_location(psess, &stack, sp, tt, &mut marker)

}

MatchedSingle(ParseNtResult::Ident(ident, is_raw)) => {

marker.visit_span(&mut sp);

}

MatchedSeq(..) => {

// We were unable to descend far enough. This is an error.

return Err(cx.dcx().create_err(VarStillRepeating { span: sp, ident }));

return Err(dcx.create_err(VarStillRepeating { span: sp, ident }));

}

};

result.push(tt)

// Replace meta-variable expressions with the result of their expansion.

mbe::TokenTree::MetaVarExpr(sp, expr) => {

transcribe_metavar_expr(cx, expr, interp, &mut marker, &repeats, &mut result, sp)?;

transcribe_metavar_expr(dcx, expr, interp, &mut marker, &repeats, &mut result, sp)?;

}

// If we are entering a new delimiter, we push its contents to the `stack` to be

/// combine with each other and not with tokens outside of the sequence.

/// - The metavariable span comes from a different crate, then we prefer the more local span.

fn maybe_use_metavar_location(

cx: &ExtCtxt<'_>,

psess: &ParseSess,

stack: &[Frame<'_>],

mut metavar_span: Span,

orig_tt: &TokenTree,

&& insert(mspans, dspan.entire(), metavar_span)

}),

};

if no_collision || cx.source_map().is_imported(metavar_span) {

if no_collision || psess.source_map().is_imported(metavar_span) {

return orig_tt.clone();

}

/// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is

/// declared inside a single repetition and the index `1` implies two nested repetitions.

fn count_repetitions<'a>(

cx: &ExtCtxt<'a>,

dcx: &'a DiagCtxt,

depth_user: usize,

mut matched: &NamedMatch,

repeats: &[(usize, usize)],

.and_then(|el| el.checked_sub(repeats.len()))

.unwrap_or_default();

if depth_user > depth_max {

return Err(out_of_bounds_err(cx, depth_max + 1, sp.entire(), "count"));

return Err(out_of_bounds_err(dcx, depth_max + 1, sp.entire(), "count"));

}

// `repeats` records all of the nested levels at which we are currently

}

if let MatchedSingle(_) = matched {

return Err(cx.dcx().create_err(CountRepetitionMisplaced { span: sp.entire() }));

return Err(dcx.create_err(CountRepetitionMisplaced { span: sp.entire() }));

}

count(depth_user, depth_max, matched)

}

/// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident]

fn matched_from_ident<'ctx, 'interp, 'rslt>(

cx: &ExtCtxt<'ctx>,

dcx: &'ctx DiagCtxt,

ident: Ident,

interp: &'interp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,

) -> PResult<'ctx, &'rslt NamedMatch>

{

let span = ident.span;

let key = MacroRulesNormalizedIdent::new(ident);

interp.get(&key).ok_or_else(|| cx.dcx().create_err(MetaVarExprUnrecognizedVar { span, key }))

interp.get(&key).ok_or_else(|| dcx.create_err(MetaVarExprUnrecognizedVar { span, key }))

}

/// Used by meta-variable expressions when an user input is out of the actual declared bounds. For

/// example, index(999999) in an repetition of only three elements.

fn out_of_bounds_err<'a>(cx: &ExtCtxt<'a>, max: usize, span: Span, ty: &str) -> Diag<'a> {

fn out_of_bounds_err<'a>(dcx: &'a DiagCtxt, max: usize, span: Span, ty: &str) -> Diag<'a> {

let msg = if max == 0 {

format!(

"meta-variable expression `{ty}` with depth parameter \

must be less than {max}"

)

};

cx.dcx().struct_span_err(span, msg)

dcx.struct_span_err(span, msg)

}

fn transcribe_metavar_expr<'a>(

cx: &ExtCtxt<'a>,

dcx: &'a DiagCtxt,

expr: &MetaVarExpr,

interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,

marker: &mut Marker,

};

match *expr {

MetaVarExpr::Count(original_ident, depth) => {

let matched = matched_from_ident(cx, original_ident, interp)?;

let count = count_repetitions(cx, depth, matched, repeats, sp)?;

let matched = matched_from_ident(dcx, original_ident, interp)?;

let count = count_repetitions(dcx, depth, matched, repeats, sp)?;

let tt = TokenTree::token_alone(

TokenKind::lit(token::Integer, sym::integer(count), None),

visited_span(),

}

MetaVarExpr::Ignore(original_ident) => {

// Used to ensure that `original_ident` is present in the LHS

let _ = matched_from_ident(cx, original_ident, interp)?;

let _ = matched_from_ident(dcx, original_ident, interp)?;

}

MetaVarExpr::Index(depth) => match repeats.iter().nth_back(depth) {

Some((index, _)) => {

visited_span(),

));

}

None => return Err(out_of_bounds_err(cx, repeats.len(), sp.entire(), "index")),

None => return Err(out_of_bounds_err(dcx, repeats.len(), sp.entire(), "index")),

},

MetaVarExpr::Len(depth) => match repeats.iter().nth_back(depth) {

Some((_, length)) => {

visited_span(),

));

}

None => return Err(out_of_bounds_err(cx, repeats.len(), sp.entire(), "len")),

None => return Err(out_of_bounds_err(dcx, repeats.len(), sp.entire(), "len")),

},

}

Ok(())