use rustc_ast as ast;
use rustc_ast::ptr::P;
-use rustc_ast::token;
+use rustc_ast::token::{self, Delimiter};
use rustc_ast::tokenstream::TokenStream;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::{Applicability, PResult};
) -> PResult<'a, ()> {
let span_start = p.prev_token.span;
- p.expect(&token::OpenDelim(token::DelimToken::Paren))?;
+ p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
- while !p.eat(&token::CloseDelim(token::DelimToken::Paren)) {
+ while !p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
if !is_global_asm && p.eat_keyword(sym::pure) {
try_set_option(p, args, sym::pure, ast::InlineAsmOptions::PURE);
} else if !is_global_asm && p.eat_keyword(sym::nomem) {
}
// Allow trailing commas
- if p.eat(&token::CloseDelim(token::DelimToken::Paren)) {
+ if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
break;
}
p.expect(&token::Comma)?;
fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a, ()> {
let span_start = p.prev_token.span;
- p.expect(&token::OpenDelim(token::DelimToken::Paren))?;
+ p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
- if p.eat(&token::CloseDelim(token::DelimToken::Paren)) {
+ if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
let err = p.sess.span_diagnostic.struct_span_err(
p.token.span,
"at least one abi must be provided as an argument to `clobber_abi`",
}
Err(opt_lit) => {
// If the non-string literal is a closing paren then it's the end of the list and is fine
- if p.eat(&token::CloseDelim(token::DelimToken::Paren)) {
+ if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
break;
}
let span = opt_lit.map_or(p.token.span, |lit| lit.span);
};
// Allow trailing commas
- if p.eat(&token::CloseDelim(token::DelimToken::Paren)) {
+ if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
break;
}
p.expect(&token::Comma)?;
p: &mut Parser<'a>,
explicit_reg: &mut bool,
) -> PResult<'a, ast::InlineAsmRegOrRegClass> {
- p.expect(&token::OpenDelim(token::DelimToken::Paren))?;
+ p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
let result = match p.token.uninterpolate().kind {
token::Ident(name, false) => ast::InlineAsmRegOrRegClass::RegClass(name),
token::Literal(token::Lit { kind: token::LitKind::Str, symbol, suffix: _ }) => {
}
};
p.bump();
- p.expect(&token::CloseDelim(token::DelimToken::Paren))?;
+ p.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
Ok(result)
}
if !parser.errors.is_empty() {
let err = parser.errors.remove(0);
- let err_sp = template_span.from_inner(err.span);
+ let err_sp = template_span.from_inner(InnerSpan::new(err.span.start, err.span.end));
let msg = &format!("invalid asm template string: {}", err.description);
let mut e = ecx.struct_span_err(err_sp, msg);
e.span_label(err_sp, err.label + " in asm template string");
e.note(¬e);
}
if let Some((label, span)) = err.secondary_label {
- let err_sp = template_span.from_inner(span);
+ let err_sp = template_span.from_inner(InnerSpan::new(span.start, span.end));
e.span_label(err_sp, label);
}
e.emit();
curarg = parser.curarg;
- let mut arg_spans = parser.arg_places.iter().map(|span| template_span.from_inner(*span));
+ let mut arg_spans = parser
+ .arg_places
+ .iter()
+ .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end)));
for piece in unverified_pieces {
match piece {
parse::Piece::String(s) => {
Some(idx)
}
}
- parse::ArgumentNamed(name, span) => match args.named_args.get(&name) {
- Some(&idx) => Some(idx),
- None => {
- let msg = format!("there is no argument named `{}`", name);
- ecx.struct_span_err(template_span.from_inner(span), &msg).emit();
- None
+ parse::ArgumentNamed(name, span) => {
+ match args.named_args.get(&Symbol::intern(name)) {
+ Some(&idx) => Some(idx),
+ None => {
+ let msg = format!("there is no argument named `{}`", name);
+ ecx.struct_span_err(
+ template_span
+ .from_inner(InnerSpan::new(span.start, span.end)),
+ &msg,
+ )
+ .emit();
+ None
+ }
}
- },
+ }
};
let mut chars = arg.format.ty.chars();
let span = arg
.format
.ty_span
- .map(|sp| template_sp.from_inner(sp))
+ .map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
.unwrap_or(template_sp);
ecx.struct_span_err(
span,
let template_num_lines = 1 + template_str.matches('\n').count();
line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
} else {
- line_spans.extend(parser.line_spans.iter().map(|span| template_span.from_inner(*span)));
+ line_spans.extend(
+ parser
+ .line_spans
+ .iter()
+ .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end))),
+ );
};
}