rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Use consistent terminology for byte string literals

Browse Source 
Avoid confusion with binary integer literals and binary operator expressions in libsyntax
This commit is contained in:
Vadim Petrochenkov
2015-09-03 10:54:53 +03:00
parent 69c3b39d0d
commit 405c616eaf
25 changed files with 69 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/libsyntax/ast.rs
View File

@@ -1190,7 +1190,7 @@ pub enum Lit_ {
/// A string literal (`"foo"`)
LitStr(InternedString, StrStyle),
/// A byte string (`b"foo"`)
LitBinary(Rc<Vec<u8>>),
LitByteStr(Rc<Vec<u8>>),
/// A byte char (`b'f'`)
LitByte(u8),
/// A character literal (`'a'`)

4
src/libsyntax/ext/concat.rs
View File

@@ -50,8 +50,8 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
accumulator.push_str(&format!("{}", b));
}
ast::LitByte(..) |
ast::LitBinary(..) => {
cx.span_err(e.span, "cannot concatenate a binary literal");
ast::LitByteStr(..) => {
cx.span_err(e.span, "cannot concatenate a byte string literal");
}
}
}

2
src/libsyntax/ext/source_util.rs
View File

@@ -189,7 +189,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
let filename = format!("{}", file.display());
cx.codemap().new_filemap_and_lines(&filename, "");
base::MacEager::expr(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
base::MacEager::expr(cx.expr_lit(sp, ast::LitByteStr(Rc::new(bytes))))
}
}
}

8
src/libsyntax/parse/lexer/mod.rs
View File

@@ -1304,7 +1304,7 @@ impl<'a> StringReader<'a> {
}
let id = if valid { self.name_from(start) } else { token::intern("??") };
self.bump();
return token::Binary(id);
return token::ByteStr(id);
}
fn scan_raw_byte_string(&mut self) -> token::Lit {
@@ -1355,7 +1355,7 @@ impl<'a> StringReader<'a> {
self.bump();
}
self.bump();
return token::BinaryRaw(self.name_from_to(content_start_bpos,
return token::ByteStrRaw(self.name_from_to(content_start_bpos,
content_end_bpos),
hash_count);
}
@@ -1546,7 +1546,7 @@ mod tests {
test!("'a'", Char, "a");
test!("b'a'", Byte, "a");
test!("\"a\"", Str_, "a");
test!("b\"a\"", Binary, "a");
test!("b\"a\"", ByteStr, "a");
test!("1234", Integer, "1234");
test!("0b101", Integer, "0b101");
test!("0xABC", Integer, "0xABC");
@@ -1560,7 +1560,7 @@ mod tests {
token::Literal(token::StrRaw(token::intern("raw"), 3),
Some(token::intern("suffix"))));
assert_eq!(setup(&mk_sh(), "br###\"raw\"###suffix".to_string()).next_token().tok,
token::Literal(token::BinaryRaw(token::intern("raw"), 3),
token::Literal(token::ByteStrRaw(token::intern("raw"), 3),
Some(token::intern("suffix"))));
}

4
src/libsyntax/parse/mod.rs
View File

@@ -499,7 +499,7 @@ pub fn byte_lit(lit: &str) -> (u8, usize) {
}
}
pub fn binary_lit(lit: &str) -> Rc<Vec<u8>> {
pub fn byte_str_lit(lit: &str) -> Rc<Vec<u8>> {
let mut res = Vec::with_capacity(lit.len());
// FIXME #8372: This could be a for-loop if it didn't borrow the iterator
@@ -517,7 +517,7 @@ pub fn binary_lit(lit: &str) -> Rc<Vec<u8>> {
}
}
// binary literals *must* be ASCII, but the escapes don't have to be
// byte string literals *must* be ASCII, but the escapes don't have to be
let mut chars = lit.bytes().enumerate().peekable();
loop {
match chars.next() {

12
src/libsyntax/parse/parser.rs
View File

@@ -34,7 +34,7 @@ use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, ItemDefaultImpl};
use ast::{ItemExternCrate, ItemUse};
use ast::{LifetimeDef, Lit, Lit_};
use ast::{LitBool, LitChar, LitByte, LitBinary};
use ast::{LitBool, LitChar, LitByte, LitByteStr};
use ast::{LitStr, LitInt, Local};
use ast::{MacStmtWithBraces, MacStmtWithSemicolon, MacStmtWithoutBraces};
use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, MatchSource};
@@ -1543,11 +1543,11 @@ impl<'a> Parser<'a> {
token::intern_and_get_ident(&parse::raw_str_lit(&s.as_str())),
ast::RawStr(n)))
}
token::Binary(i) =>
(true, LitBinary(parse::binary_lit(&i.as_str()))),
token::BinaryRaw(i, _) =>
token::ByteStr(i) =>
(true, LitByteStr(parse::byte_str_lit(&i.as_str()))),
token::ByteStrRaw(i, _) =>
(true,
LitBinary(Rc::new(i.to_string().into_bytes()))),
LitByteStr(Rc::new(i.to_string().into_bytes()))),
};
if suffix_illegal {
@@ -5826,7 +5826,7 @@ impl<'a> Parser<'a> {
match try!(self.parse_optional_str()) {
Some((s, style, suf)) => {
let sp = self.last_span;
self.expect_no_suffix(sp, "str literal", suf);
self.expect_no_suffix(sp, "string literal", suf);
Ok((s, style))
}
_ => Err(self.fatal("expected string literal"))

8
src/libsyntax/parse/token.rs
View File

@@ -82,8 +82,8 @@ pub enum Lit {
Float(ast::Name),
Str_(ast::Name),
StrRaw(ast::Name, usize), /* raw str delimited by n hash symbols */
Binary(ast::Name),
BinaryRaw(ast::Name, usize), /* raw binary str delimited by n hash symbols */
ByteStr(ast::Name),
ByteStrRaw(ast::Name, usize), /* raw byte str delimited by n hash symbols */
}
impl Lit {
@@ -93,8 +93,8 @@ impl Lit {
Char(_) => "char",
Integer(_) => "integer",
Float(_) => "float",
Str_(_) | StrRaw(..) => "str",
Binary(_) | BinaryRaw(..) => "binary str"
Str_(_) | StrRaw(..) => "string",
ByteStr(_) | ByteStrRaw(..) => "byte string"
}
}
}

6
src/libsyntax/print/pprust.rs
View File

@@ -259,8 +259,8 @@ pub fn token_to_string(tok: &Token) -> String {
token::StrRaw(s, n) => format!("r{delim}\"{string}\"{delim}",
delim=repeat("#", n),
string=s),
token::Binary(v) => format!("b\"{}\"", v),
token::BinaryRaw(s, n) => format!("br{delim}\"{string}\"{delim}",
token::ByteStr(v) => format!("b\"{}\"", v),
token::ByteStrRaw(s, n) => format!("br{delim}\"{string}\"{delim}",
delim=repeat("#", n),
string=s),
};
@@ -2887,7 +2887,7 @@ impl<'a> State<'a> {
ast::LitBool(val) => {
if val { word(&mut self.s, "true") } else { word(&mut self.s, "false") }
}
ast::LitBinary(ref v) => {
ast::LitByteStr(ref v) => {
let mut escaped: String = String::new();
for &ch in v.iter() {
escaped.extend(ascii::escape_default(ch)