syntax: Some code cleanup
This commit is contained in:
Vadim Petrochenkov
parent
ca2a50fad7
commit
90d15e7704
9 changed files with 177 additions and 228 deletions
|
|
@ -6,7 +6,7 @@ use crate::parse::PResult;
|
|||
use crate::parse::token::{self, Token};
|
||||
use crate::parse::unescape::{unescape_str, unescape_char, unescape_byte_str, unescape_byte};
|
||||
use crate::print::pprust;
|
||||
use crate::symbol::{kw, Symbol};
|
||||
use crate::symbol::{kw, sym, Symbol};
|
||||
use crate::tokenstream::{TokenStream, TokenTree};
|
||||
|
||||
use errors::{Applicability, Handler};
|
||||
|
|
@ -22,22 +22,23 @@ crate enum LitError {
|
|||
InvalidSuffix,
|
||||
InvalidIntSuffix,
|
||||
InvalidFloatSuffix,
|
||||
NonDecimalFloat(&'static str),
|
||||
NonDecimalFloat(u32),
|
||||
IntTooLarge,
|
||||
}
|
||||
|
||||
impl LitError {
|
||||
crate fn report(
|
||||
&self,
|
||||
diag: &Handler,
|
||||
token::Lit { kind, suffix, .. }: token::Lit,
|
||||
span: Span,
|
||||
) {
|
||||
fn report(&self, diag: &Handler, lit: token::Lit, span: Span) {
|
||||
let token::Lit { kind, suffix, .. } = lit;
|
||||
match *self {
|
||||
LitError::NotLiteral | LitError::LexerError => {}
|
||||
// `NotLiteral` is not an error by itself, so we don't report
|
||||
// it and give the parser opportunity to try something else.
|
||||
LitError::NotLiteral => {}
|
||||
// `LexerError` *is* an error, but it was already reported
|
||||
// by lexer, so here we don't report it the second time.
|
||||
LitError::LexerError => {}
|
||||
LitError::InvalidSuffix => {
|
||||
expect_no_suffix(
|
||||
diag, span, &format!("{} {}", kind.article(), kind.descr()), suffix
|
||||
diag, span, &format!("{} {} literal", kind.article(), kind.descr()), suffix
|
||||
);
|
||||
}
|
||||
LitError::InvalidIntSuffix => {
|
||||
|
|
@ -72,7 +73,13 @@ impl LitError {
|
|||
.emit();
|
||||
}
|
||||
}
|
||||
LitError::NonDecimalFloat(descr) => {
|
||||
LitError::NonDecimalFloat(base) => {
|
||||
let descr = match base {
|
||||
16 => "hexadecimal",
|
||||
8 => "octal",
|
||||
2 => "binary",
|
||||
_ => unreachable!(),
|
||||
};
|
||||
diag.struct_span_err(span, &format!("{} float literal is not supported", descr))
|
||||
.span_label(span, "not supported")
|
||||
.emit();
|
||||
|
|
@ -86,13 +93,9 @@ impl LitError {
|
|||
}
|
||||
|
||||
impl LitKind {
|
||||
/// Converts literal token with a suffix into a semantic literal.
|
||||
/// Works speculatively and may return `None` if diagnostic handler is not passed.
|
||||
/// If diagnostic handler is passed, always returns `Some`,
|
||||
/// possibly after reporting non-fatal errors and recovery.
|
||||
fn from_lit_token(
|
||||
token::Lit { kind, symbol, suffix }: token::Lit,
|
||||
) -> Result<LitKind, LitError> {
|
||||
/// Converts literal token into a semantic literal.
|
||||
fn from_lit_token(lit: token::Lit) -> Result<LitKind, LitError> {
|
||||
let token::Lit { kind, symbol, suffix } = lit;
|
||||
if suffix.is_some() && !kind.may_have_suffix() {
|
||||
return Err(LitError::InvalidSuffix);
|
||||
}
|
||||
|
|
@ -102,18 +105,10 @@ impl LitKind {
|
|||
assert!(symbol == kw::True || symbol == kw::False);
|
||||
LitKind::Bool(symbol == kw::True)
|
||||
}
|
||||
token::Byte => {
|
||||
match unescape_byte(&symbol.as_str()) {
|
||||
Ok(c) => LitKind::Byte(c),
|
||||
Err(_) => return Err(LitError::LexerError),
|
||||
}
|
||||
},
|
||||
token::Char => {
|
||||
match unescape_char(&symbol.as_str()) {
|
||||
Ok(c) => LitKind::Char(c),
|
||||
Err(_) => return Err(LitError::LexerError),
|
||||
}
|
||||
},
|
||||
token::Byte => return unescape_byte(&symbol.as_str())
|
||||
.map(LitKind::Byte).map_err(|_| LitError::LexerError),
|
||||
token::Char => return unescape_char(&symbol.as_str())
|
||||
.map(LitKind::Char).map_err(|_| LitError::LexerError),
|
||||
|
||||
// There are some valid suffixes for integer and float literals,
|
||||
// so all the handling is done internally.
|
||||
|
|
@ -125,53 +120,48 @@ impl LitKind {
|
|||
// reuse the symbol from the token. Otherwise, we must generate a
|
||||
// new symbol because the string in the LitKind is different to the
|
||||
// string in the token.
|
||||
let mut error = None;
|
||||
let mut sym = symbol;
|
||||
let s = &sym.as_str();
|
||||
if s.as_bytes().iter().any(|&c| c == b'\\' || c == b'\r') {
|
||||
let s = symbol.as_str();
|
||||
let symbol = if s.contains(&['\\', '\r'][..]) {
|
||||
let mut buf = String::with_capacity(s.len());
|
||||
unescape_str(s, &mut |_, unescaped_char| {
|
||||
let mut error = Ok(());
|
||||
unescape_str(&s, &mut |_, unescaped_char| {
|
||||
match unescaped_char {
|
||||
Ok(c) => buf.push(c),
|
||||
Err(_) => error = Some(LitError::LexerError),
|
||||
Err(_) => error = Err(LitError::LexerError),
|
||||
}
|
||||
});
|
||||
if let Some(error) = error {
|
||||
return Err(error);
|
||||
}
|
||||
sym = Symbol::intern(&buf)
|
||||
}
|
||||
|
||||
LitKind::Str(sym, ast::StrStyle::Cooked)
|
||||
error?;
|
||||
Symbol::intern(&buf)
|
||||
} else {
|
||||
symbol
|
||||
};
|
||||
LitKind::Str(symbol, ast::StrStyle::Cooked)
|
||||
}
|
||||
token::StrRaw(n) => {
|
||||
// Ditto.
|
||||
let mut sym = symbol;
|
||||
let s = &sym.as_str();
|
||||
if s.contains('\r') {
|
||||
sym = Symbol::intern(&raw_str_lit(s));
|
||||
}
|
||||
LitKind::Str(sym, ast::StrStyle::Raw(n))
|
||||
let s = symbol.as_str();
|
||||
let symbol = if s.contains('\r') {
|
||||
Symbol::intern(&raw_str_lit(&s))
|
||||
} else {
|
||||
symbol
|
||||
};
|
||||
LitKind::Str(symbol, ast::StrStyle::Raw(n))
|
||||
}
|
||||
token::ByteStr => {
|
||||
let s = &symbol.as_str();
|
||||
let s = symbol.as_str();
|
||||
let mut buf = Vec::with_capacity(s.len());
|
||||
let mut error = None;
|
||||
unescape_byte_str(s, &mut |_, unescaped_byte| {
|
||||
let mut error = Ok(());
|
||||
unescape_byte_str(&s, &mut |_, unescaped_byte| {
|
||||
match unescaped_byte {
|
||||
Ok(c) => buf.push(c),
|
||||
Err(_) => error = Some(LitError::LexerError),
|
||||
Err(_) => error = Err(LitError::LexerError),
|
||||
}
|
||||
});
|
||||
if let Some(error) = error {
|
||||
return Err(error);
|
||||
}
|
||||
error?;
|
||||
buf.shrink_to_fit();
|
||||
LitKind::ByteStr(Lrc::new(buf))
|
||||
}
|
||||
token::ByteStrRaw(_) => {
|
||||
LitKind::ByteStr(Lrc::new(symbol.to_string().into_bytes()))
|
||||
}
|
||||
token::ByteStrRaw(_) => LitKind::ByteStr(Lrc::new(symbol.to_string().into_bytes())),
|
||||
token::Err => LitKind::Err(symbol),
|
||||
})
|
||||
}
|
||||
|
|
@ -229,21 +219,13 @@ impl LitKind {
|
|||
}
|
||||
|
||||
impl Lit {
|
||||
fn from_lit_token(
|
||||
token: token::Lit,
|
||||
span: Span,
|
||||
) -> Result<Lit, LitError> {
|
||||
/// Converts literal token into an AST literal.
|
||||
fn from_lit_token(token: token::Lit, span: Span) -> Result<Lit, LitError> {
|
||||
Ok(Lit { token, node: LitKind::from_lit_token(token)?, span })
|
||||
}
|
||||
|
||||
/// Converts literal token with a suffix into an AST literal.
|
||||
/// Works speculatively and may return `None` if diagnostic handler is not passed.
|
||||
/// If diagnostic handler is passed, may return `Some`,
|
||||
/// possibly after reporting non-fatal errors and recovery, or `None` for irrecoverable errors.
|
||||
crate fn from_token(
|
||||
token: &token::Token,
|
||||
span: Span,
|
||||
) -> Result<Lit, LitError> {
|
||||
/// Converts arbitrary token into an AST literal.
|
||||
crate fn from_token(token: &Token, span: Span) -> Result<Lit, LitError> {
|
||||
let lit = match *token {
|
||||
token::Ident(ident, false) if ident.name == kw::True || ident.name == kw::False =>
|
||||
token::Lit::new(token::Bool, ident.name, None),
|
||||
|
|
@ -298,6 +280,7 @@ impl<'a> Parser<'a> {
|
|||
None
|
||||
});
|
||||
if let Some((ref token, span)) = recovered {
|
||||
self.bump();
|
||||
self.diagnostic()
|
||||
.struct_span_err(span, "float literals must have an integer part")
|
||||
.span_suggestion(
|
||||
|
|
@ -307,7 +290,6 @@ impl<'a> Parser<'a> {
|
|||
Applicability::MachineApplicable,
|
||||
)
|
||||
.emit();
|
||||
self.bump();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -317,64 +299,59 @@ impl<'a> Parser<'a> {
|
|||
match Lit::from_token(token, span) {
|
||||
Ok(lit) => {
|
||||
self.bump();
|
||||
return Ok(lit);
|
||||
Ok(lit)
|
||||
}
|
||||
Err(LitError::NotLiteral) => {
|
||||
let msg = format!("unexpected token: {}", self.this_token_descr());
|
||||
return Err(self.span_fatal(span, &msg));
|
||||
Err(self.span_fatal(span, &msg))
|
||||
}
|
||||
Err(err) => {
|
||||
let lit = token.expect_lit();
|
||||
self.bump();
|
||||
err.report(&self.sess.span_diagnostic, lit, span);
|
||||
let lit = token::Lit::new(token::Err, lit.symbol, lit.suffix);
|
||||
return Ok(Lit::from_lit_token(lit, span).ok().unwrap());
|
||||
Lit::from_lit_token(lit, span).map_err(|_| unreachable!())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
crate fn expect_no_suffix(diag: &Handler, sp: Span, kind: &str, suffix: Option<ast::Name>) {
|
||||
match suffix {
|
||||
None => {/* everything ok */}
|
||||
Some(suf) => {
|
||||
let text = suf.as_str();
|
||||
let mut err = if kind == "a tuple index" &&
|
||||
["i32", "u32", "isize", "usize"].contains(&text.to_string().as_str())
|
||||
{
|
||||
// #59553: warn instead of reject out of hand to allow the fix to percolate
|
||||
// through the ecosystem when people fix their macros
|
||||
let mut err = diag.struct_span_warn(
|
||||
sp,
|
||||
&format!("suffixes on {} are invalid", kind),
|
||||
);
|
||||
err.note(&format!(
|
||||
"`{}` is *temporarily* accepted on tuple index fields as it was \
|
||||
incorrectly accepted on stable for a few releases",
|
||||
text,
|
||||
));
|
||||
err.help(
|
||||
"on proc macros, you'll want to use `syn::Index::from` or \
|
||||
`proc_macro::Literal::*_unsuffixed` for code that will desugar \
|
||||
to tuple field access",
|
||||
);
|
||||
err.note(
|
||||
"for more context, see https://github.com/rust-lang/rust/issues/60210",
|
||||
);
|
||||
err
|
||||
} else {
|
||||
diag.struct_span_err(sp, &format!("suffixes on {} are invalid", kind))
|
||||
};
|
||||
err.span_label(sp, format!("invalid suffix `{}`", text));
|
||||
err.emit();
|
||||
}
|
||||
crate fn expect_no_suffix(diag: &Handler, sp: Span, kind: &str, suffix: Option<Symbol>) {
|
||||
if let Some(suf) = suffix {
|
||||
let mut err = if kind == "a tuple index" &&
|
||||
[sym::i32, sym::u32, sym::isize, sym::usize].contains(&suf) {
|
||||
// #59553: warn instead of reject out of hand to allow the fix to percolate
|
||||
// through the ecosystem when people fix their macros
|
||||
let mut err = diag.struct_span_warn(
|
||||
sp,
|
||||
&format!("suffixes on {} are invalid", kind),
|
||||
);
|
||||
err.note(&format!(
|
||||
"`{}` is *temporarily* accepted on tuple index fields as it was \
|
||||
incorrectly accepted on stable for a few releases",
|
||||
suf,
|
||||
));
|
||||
err.help(
|
||||
"on proc macros, you'll want to use `syn::Index::from` or \
|
||||
`proc_macro::Literal::*_unsuffixed` for code that will desugar \
|
||||
to tuple field access",
|
||||
);
|
||||
err.note(
|
||||
"for more context, see https://github.com/rust-lang/rust/issues/60210",
|
||||
);
|
||||
err
|
||||
} else {
|
||||
diag.struct_span_err(sp, &format!("suffixes on {} are invalid", kind))
|
||||
};
|
||||
err.span_label(sp, format!("invalid suffix `{}`", suf));
|
||||
err.emit();
|
||||
}
|
||||
}
|
||||
|
||||
/// Parses a string representing a raw string literal into its final form. The
|
||||
/// only operation this does is convert embedded CRLF into a single LF.
|
||||
fn raw_str_lit(lit: &str) -> String {
|
||||
debug!("raw_str_lit: given {}", lit.escape_default());
|
||||
debug!("raw_str_lit: {:?}", lit);
|
||||
let mut res = String::with_capacity(lit.len());
|
||||
|
||||
let mut chars = lit.chars().peekable();
|
||||
|
|
@ -399,117 +376,82 @@ fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
|
|||
s.len() > 1 && s.starts_with(first_chars) && s[1..].chars().all(|c| c.is_ascii_digit())
|
||||
}
|
||||
|
||||
fn filtered_float_lit(data: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
|
||||
debug!("filtered_float_lit: {}, {:?}", data, suffix);
|
||||
let suffix = match suffix {
|
||||
Some(suffix) => suffix,
|
||||
None => return Ok(LitKind::FloatUnsuffixed(data)),
|
||||
};
|
||||
fn strip_underscores(symbol: Symbol) -> Symbol {
|
||||
// Do not allocate a new string unless necessary.
|
||||
let s = symbol.as_str();
|
||||
if s.contains('_') {
|
||||
let mut s = s.to_string();
|
||||
s.retain(|c| c != '_');
|
||||
return Symbol::intern(&s);
|
||||
}
|
||||
symbol
|
||||
}
|
||||
|
||||
Ok(match &*suffix.as_str() {
|
||||
"f32" => LitKind::Float(data, ast::FloatTy::F32),
|
||||
"f64" => LitKind::Float(data, ast::FloatTy::F64),
|
||||
_ => return Err(LitError::InvalidFloatSuffix),
|
||||
fn filtered_float_lit(symbol: Symbol, suffix: Option<Symbol>, base: u32)
|
||||
-> Result<LitKind, LitError> {
|
||||
debug!("filtered_float_lit: {:?}, {:?}, {:?}", symbol, suffix, base);
|
||||
if base != 10 {
|
||||
return Err(LitError::NonDecimalFloat(base));
|
||||
}
|
||||
Ok(match suffix {
|
||||
Some(suf) => match suf {
|
||||
sym::f32 => LitKind::Float(symbol, ast::FloatTy::F32),
|
||||
sym::f64 => LitKind::Float(symbol, ast::FloatTy::F64),
|
||||
_ => return Err(LitError::InvalidFloatSuffix),
|
||||
}
|
||||
None => LitKind::FloatUnsuffixed(symbol)
|
||||
})
|
||||
}
|
||||
|
||||
fn float_lit(s: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
|
||||
debug!("float_lit: {:?}, {:?}", s, suffix);
|
||||
// FIXME #2252: bounds checking float literals is deferred until trans
|
||||
|
||||
// Strip underscores without allocating a new String unless necessary.
|
||||
let s2;
|
||||
let s = s.as_str();
|
||||
let s = s.get();
|
||||
let s = if s.chars().any(|c| c == '_') {
|
||||
s2 = s.chars().filter(|&c| c != '_').collect::<String>();
|
||||
&s2
|
||||
} else {
|
||||
s
|
||||
};
|
||||
|
||||
filtered_float_lit(Symbol::intern(s), suffix)
|
||||
fn float_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
|
||||
debug!("float_lit: {:?}, {:?}", symbol, suffix);
|
||||
filtered_float_lit(strip_underscores(symbol), suffix, 10)
|
||||
}
|
||||
|
||||
fn integer_lit(s: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
|
||||
// s can only be ascii, byte indexing is fine
|
||||
|
||||
// Strip underscores without allocating a new String unless necessary.
|
||||
let s2;
|
||||
let orig = s;
|
||||
let s = s.as_str();
|
||||
let s = s.get();
|
||||
let mut s = if s.chars().any(|c| c == '_') {
|
||||
s2 = s.chars().filter(|&c| c != '_').collect::<String>();
|
||||
&s2
|
||||
} else {
|
||||
s
|
||||
};
|
||||
|
||||
debug!("integer_lit: {}, {:?}", s, suffix);
|
||||
fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
|
||||
debug!("integer_lit: {:?}, {:?}", symbol, suffix);
|
||||
let symbol = strip_underscores(symbol);
|
||||
let s = symbol.as_str();
|
||||
|
||||
let mut base = 10;
|
||||
let mut ty = ast::LitIntType::Unsuffixed;
|
||||
|
||||
if s.starts_with('0') && s.len() > 1 {
|
||||
if s.len() > 1 && s.as_bytes()[0] == b'0' {
|
||||
match s.as_bytes()[1] {
|
||||
b'x' => base = 16,
|
||||
b'o' => base = 8,
|
||||
b'b' => base = 2,
|
||||
_ => { }
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
// 1f64 and 2f32 etc. are valid float literals.
|
||||
if let Some(suf) = suffix {
|
||||
if looks_like_width_suffix(&['f'], &suf.as_str()) {
|
||||
let err = match base {
|
||||
16 => Some(LitError::NonDecimalFloat("hexadecimal")),
|
||||
8 => Some(LitError::NonDecimalFloat("octal")),
|
||||
2 => Some(LitError::NonDecimalFloat("binary")),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(err) = err {
|
||||
return Err(err);
|
||||
}
|
||||
return filtered_float_lit(Symbol::intern(s), Some(suf))
|
||||
}
|
||||
}
|
||||
|
||||
if base != 10 {
|
||||
s = &s[2..];
|
||||
}
|
||||
|
||||
if let Some(suf) = suffix {
|
||||
ty = match &*suf.as_str() {
|
||||
"isize" => ast::LitIntType::Signed(ast::IntTy::Isize),
|
||||
"i8" => ast::LitIntType::Signed(ast::IntTy::I8),
|
||||
"i16" => ast::LitIntType::Signed(ast::IntTy::I16),
|
||||
"i32" => ast::LitIntType::Signed(ast::IntTy::I32),
|
||||
"i64" => ast::LitIntType::Signed(ast::IntTy::I64),
|
||||
"i128" => ast::LitIntType::Signed(ast::IntTy::I128),
|
||||
"usize" => ast::LitIntType::Unsigned(ast::UintTy::Usize),
|
||||
"u8" => ast::LitIntType::Unsigned(ast::UintTy::U8),
|
||||
"u16" => ast::LitIntType::Unsigned(ast::UintTy::U16),
|
||||
"u32" => ast::LitIntType::Unsigned(ast::UintTy::U32),
|
||||
"u64" => ast::LitIntType::Unsigned(ast::UintTy::U64),
|
||||
"u128" => ast::LitIntType::Unsigned(ast::UintTy::U128),
|
||||
let ty = match suffix {
|
||||
Some(suf) => match suf {
|
||||
sym::isize => ast::LitIntType::Signed(ast::IntTy::Isize),
|
||||
sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8),
|
||||
sym::i16 => ast::LitIntType::Signed(ast::IntTy::I16),
|
||||
sym::i32 => ast::LitIntType::Signed(ast::IntTy::I32),
|
||||
sym::i64 => ast::LitIntType::Signed(ast::IntTy::I64),
|
||||
sym::i128 => ast::LitIntType::Signed(ast::IntTy::I128),
|
||||
sym::usize => ast::LitIntType::Unsigned(ast::UintTy::Usize),
|
||||
sym::u8 => ast::LitIntType::Unsigned(ast::UintTy::U8),
|
||||
sym::u16 => ast::LitIntType::Unsigned(ast::UintTy::U16),
|
||||
sym::u32 => ast::LitIntType::Unsigned(ast::UintTy::U32),
|
||||
sym::u64 => ast::LitIntType::Unsigned(ast::UintTy::U64),
|
||||
sym::u128 => ast::LitIntType::Unsigned(ast::UintTy::U128),
|
||||
// `1f64` and `2f32` etc. are valid float literals, and
|
||||
// `fxxx` looks more like an invalid float literal than invalid integer literal.
|
||||
_ if suf.as_str().starts_with('f') => return filtered_float_lit(symbol, suffix, base),
|
||||
_ => return Err(LitError::InvalidIntSuffix),
|
||||
}
|
||||
}
|
||||
_ => ast::LitIntType::Unsuffixed
|
||||
};
|
||||
|
||||
debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
|
||||
string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
|
||||
|
||||
Ok(match u128::from_str_radix(s, base) {
|
||||
Ok(r) => LitKind::Int(r, ty),
|
||||
Err(_) => {
|
||||
// Small bases are lexed as if they were base 10, e.g, the string
|
||||
// might be `0b10201`. This will cause the conversion above to fail,
|
||||
// but these kinds of errors are already reported by the lexer.
|
||||
let from_lexer =
|
||||
base < 10 && s.chars().any(|c| c.to_digit(10).map_or(false, |d| d >= base));
|
||||
return Err(if from_lexer { LitError::LexerError } else { LitError::IntTooLarge });
|
||||
}
|
||||
let s = &s[if base != 10 { 2 } else { 0 } ..];
|
||||
u128::from_str_radix(s, base).map(|i| LitKind::Int(i, ty)).map_err(|_| {
|
||||
// Small bases are lexed as if they were base 10, e.g, the string
|
||||
// might be `0b10201`. This will cause the conversion above to fail,
|
||||
// but these kinds of errors are already reported by the lexer.
|
||||
let from_lexer =
|
||||
base < 10 && s.chars().any(|c| c.to_digit(10).map_or(false, |d| d >= base));
|
||||
if from_lexer { LitError::LexerError } else { LitError::IntTooLarge }
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -73,6 +73,7 @@ pub enum LitKind {
|
|||
Err,
|
||||
}
|
||||
|
||||
/// A literal token.
|
||||
#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)]
|
||||
pub struct Lit {
|
||||
pub kind: LitKind,
|
||||
|
|
@ -81,6 +82,7 @@ pub struct Lit {
|
|||
}
|
||||
|
||||
impl LitKind {
|
||||
/// An English article for the literal token kind.
|
||||
crate fn article(self) -> &'static str {
|
||||
match self {
|
||||
Integer | Err => "an",
|
||||
|
|
@ -91,13 +93,13 @@ impl LitKind {
|
|||
crate fn descr(self) -> &'static str {
|
||||
match self {
|
||||
Bool => panic!("literal token contains `Lit::Bool`"),
|
||||
Byte => "byte literal",
|
||||
Char => "char literal",
|
||||
Integer => "integer literal",
|
||||
Float => "float literal",
|
||||
Str | StrRaw(..) => "string literal",
|
||||
ByteStr | ByteStrRaw(..) => "byte string literal",
|
||||
Err => "invalid literal",
|
||||
Byte => "byte",
|
||||
Char => "char",
|
||||
Integer => "integer",
|
||||
Float => "float",
|
||||
Str | StrRaw(..) => "string",
|
||||
ByteStr | ByteStrRaw(..) => "byte string",
|
||||
Err => "error",
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -163,7 +163,8 @@ fn binop_to_string(op: BinOpToken) -> &'static str {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn literal_to_string(token::Lit { kind, symbol, suffix }: token::Lit) -> String {
|
||||
pub fn literal_to_string(lit: token::Lit) -> String {
|
||||
let token::Lit { kind, symbol, suffix } = lit;
|
||||
let mut out = match kind {
|
||||
token::Byte => format!("b'{}'", symbol),
|
||||
token::Char => format!("'{}'", symbol),
|
||||
|
|
|
|||
|
|
@ -379,7 +379,7 @@ impl<'a> Rustc<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn lit(&mut self, kind: token::LitKind, symbol: Symbol, suffix: Option<Symbol>) -> Literal {
|
||||
fn lit(&mut self, kind: token::LitKind, symbol: Symbol, suffix: Option<Symbol>) -> Literal {
|
||||
Literal {
|
||||
lit: token::Lit::new(kind, symbol, suffix),
|
||||
span: server::Span::call_site(self),
|
||||
|
|
|
|||
|
|
@ -246,6 +246,8 @@ symbols! {
|
|||
extern_prelude,
|
||||
extern_types,
|
||||
f16c_target_feature,
|
||||
f32,
|
||||
f64,
|
||||
feature,
|
||||
ffi_returns_twice,
|
||||
field_init_shorthand,
|
||||
|
|
|
|||
|
|
@ -13,8 +13,10 @@ fn main() {
|
|||
0o; //~ ERROR: no valid digits
|
||||
1e+; //~ ERROR: expected at least one digit in exponent
|
||||
0x539.0; //~ ERROR: hexadecimal float literal is not supported
|
||||
9900000000000000000000000000999999999999999999999999999999; //~ ERROR: integer literal is too large
|
||||
9900000000000000000000000000999999999999999999999999999999; //~ ERROR: integer literal is too large
|
||||
9900000000000000000000000000999999999999999999999999999999;
|
||||
//~^ ERROR: integer literal is too large
|
||||
9900000000000000000000000000999999999999999999999999999999;
|
||||
//~^ ERROR: integer literal is too large
|
||||
0x; //~ ERROR: no valid digits
|
||||
0xu32; //~ ERROR: no valid digits
|
||||
0ou32; //~ ERROR: no valid digits
|
||||
|
|
|
|||
|
|
@ -65,43 +65,43 @@ LL | 0x539.0;
|
|||
| ^^^^^^^
|
||||
|
||||
error: no valid digits found for number
|
||||
--> $DIR/lex-bad-numeric-literals.rs:18:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:20:5
|
||||
|
|
||||
LL | 0x;
|
||||
| ^^
|
||||
|
||||
error: no valid digits found for number
|
||||
--> $DIR/lex-bad-numeric-literals.rs:19:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:21:5
|
||||
|
|
||||
LL | 0xu32;
|
||||
| ^^
|
||||
|
||||
error: no valid digits found for number
|
||||
--> $DIR/lex-bad-numeric-literals.rs:20:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:22:5
|
||||
|
|
||||
LL | 0ou32;
|
||||
| ^^
|
||||
|
||||
error: no valid digits found for number
|
||||
--> $DIR/lex-bad-numeric-literals.rs:21:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:23:5
|
||||
|
|
||||
LL | 0bu32;
|
||||
| ^^
|
||||
|
||||
error: no valid digits found for number
|
||||
--> $DIR/lex-bad-numeric-literals.rs:22:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:24:5
|
||||
|
|
||||
LL | 0b;
|
||||
| ^^
|
||||
|
||||
error: octal float literal is not supported
|
||||
--> $DIR/lex-bad-numeric-literals.rs:24:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:26:5
|
||||
|
|
||||
LL | 0o123.456;
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: binary float literal is not supported
|
||||
--> $DIR/lex-bad-numeric-literals.rs:26:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:28:5
|
||||
|
|
||||
LL | 0b111.101;
|
||||
| ^^^^^^^^^
|
||||
|
|
@ -119,19 +119,19 @@ LL | 9900000000000000000000000000999999999999999999999999999999;
|
|||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: integer literal is too large
|
||||
--> $DIR/lex-bad-numeric-literals.rs:17:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:18:5
|
||||
|
|
||||
LL | 9900000000000000000000000000999999999999999999999999999999;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: octal float literal is not supported
|
||||
--> $DIR/lex-bad-numeric-literals.rs:23:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:25:5
|
||||
|
|
||||
LL | 0o123f64;
|
||||
| ^^^^^^^^ not supported
|
||||
|
||||
error: binary float literal is not supported
|
||||
--> $DIR/lex-bad-numeric-literals.rs:25:5
|
||||
--> $DIR/lex-bad-numeric-literals.rs:27:5
|
||||
|
|
||||
LL | 0b101f64;
|
||||
| ^^^^^^^^ not supported
|
||||
|
|
|
|||
|
|
@ -4,6 +4,6 @@ fn main() {
|
|||
0x567.89;
|
||||
//~^ ERROR hexadecimal float literal is not supported
|
||||
0xDEAD.BEEFp-2f;
|
||||
//~^ ERROR invalid suffix `f` for integer literal
|
||||
//~^ ERROR invalid suffix `f` for float literal
|
||||
//~| ERROR `{integer}` is a primitive type and therefore doesn't have fields
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,13 +4,13 @@ error: hexadecimal float literal is not supported
|
|||
LL | 0x567.89;
|
||||
| ^^^^^^^^
|
||||
|
||||
error: invalid suffix `f` for integer literal
|
||||
error: invalid suffix `f` for float literal
|
||||
--> $DIR/no-hex-float-literal.rs:6:18
|
||||
|
|
||||
LL | 0xDEAD.BEEFp-2f;
|
||||
| ^^ invalid suffix `f`
|
||||
|
|
||||
= help: the suffix must be one of the integral types (`u32`, `isize`, etc)
|
||||
= help: valid suffixes are `f32` and `f64`
|
||||
|
||||
error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields
|
||||
--> $DIR/no-hex-float-literal.rs:2:11
|
||||
|
|
|
|||
Loading…
Reference in a new issue