mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #28220 - steveklabnik:rollup, r=steveklabnik

Browse Source 
- Successful merges: #28167, #28202, #28203, #28204, #28205, #28207, #28208, #28209, #28210, #28212, #28213, #28214, #28215, #28216
- Failed merges:
This commit is contained in:
bors 2015-09-04 02:33:44 +00:00
commit 35b14544e1
31 changed files with 97 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/doc/grammar.md
View File

@ -281,7 +281,7 @@ type_path_tail : '<' type_expr [ ',' type_expr ] + '>'
## Macros
```antlr
expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';'
expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';'
| "macro_rules" '!' ident '{' macro_rule * '}' ;
macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
matcher : '(' matcher * ')' | '[' matcher * ']'
@ -306,7 +306,7 @@ transcriber : '(' transcriber * ')' | '[' transcriber * ']'
```antlr
item : vis ? mod_item | fn_item | type_item | struct_item | enum_item
| const_item | static_item | trait_item | impl_item | extern_block ;
| const_item | static_item | trait_item | impl_item | extern_block_item ;
```
### Type Parameters
@ -636,31 +636,31 @@ lambda_expr : '|' ident_list '|' expr ;
### While loops
```antlr
while_expr : [ lifetime ':' ] "while" no_struct_literal_expr '{' block '}' ;
while_expr : [ lifetime ':' ] ? "while" no_struct_literal_expr '{' block '}' ;
```
### Infinite loops
```antlr
loop_expr : [ lifetime ':' ] "loop" '{' block '}';
loop_expr : [ lifetime ':' ] ? "loop" '{' block '}';
```
### Break expressions
```antlr
break_expr : "break" [ lifetime ];
break_expr : "break" [ lifetime ] ?;
```
### Continue expressions
```antlr
continue_expr : "continue" [ lifetime ];
continue_expr : "continue" [ lifetime ] ?;
```
### For expressions
```antlr
for_expr : [ lifetime ':' ] "for" pat "in" no_struct_literal_expr '{' block '}' ;
for_expr : [ lifetime ':' ] ? "for" pat "in" no_struct_literal_expr '{' block '}' ;
```
### If expressions
@ -688,13 +688,12 @@ match_pat : pat [ '|' pat ] * [ "if" expr ] ? ;
```antlr
if_let_expr : "if" "let" pat '=' expr '{' block '}'
else_tail ? ;
else_tail : "else" [ if_expr | if_let_expr | '{' block '}' ] ;
```
### While let loops
```antlr
while_let_expr : "while" "let" pat '=' expr '{' block '}' ;
while_let_expr : [ lifetime ':' ] ? "while" "let" pat '=' expr '{' block '}' ;
```
### Return expressions
@ -754,8 +753,6 @@ return_expr : "return" expr ? ;
```antlr
closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
[ ':' bound-list ] [ '->' type ]
procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
[ ':' bound-list ] [ '->' type ]
lifetime-list := lifetime | lifetime ',' lifetime-list
arg-list := ident ':' type | ident ':' type ',' arg-list
bound-list := bound | bound '+' bound-list

10
src/doc/reference.md
View File

@ -3200,16 +3200,6 @@ let z = match x { &0 => "zero", _ => "some" };
assert_eq!(y, z);
```
A pattern that's just an identifier, like `Nil` in the previous example, could
either refer to an enum variant that's in scope, or bind a new variable. The
compiler resolves this ambiguity by forbidding variable bindings that occur in
`match` patterns from shadowing names of variants that are in scope. For
example, wherever `List` is in scope, a `match` pattern would not be able to
bind `Nil` as a new name. The compiler interprets a variable pattern `x` as a
binding _only_ if there is no variant named `x` in scope. A convention you can
use to avoid conflicts is simply to name variants with upper-case letters, and
local variables with lower-case letters.
Multiple match patterns may be joined with the `|` operator. A range of values
may be specified with `...`. For example:

12
src/doc/trpl/choosing-your-guarantees.md
View File

@ -1,6 +1,6 @@
% Choosing your Guarantees
One important feature of Rust as language is that it lets us control the costs and guarantees
One important feature of Rust is that it lets us control the costs and guarantees
of a program.
There are various &ldquo;wrapper type&rdquo; abstractions in the Rust standard library which embody
@ -18,9 +18,9 @@ Before proceeding, it is highly recommended that one reads about [ownership][own
## `Box<T>`
[`Box<T>`][box] is pointer which is &ldquo;owned&rdquo;, or a &ldquo;box&rdquo;. While it can hand
out references to the contained data, it is the only owner of the data. In particular, when
something like the following occurs:
[`Box<T>`][box] is an &ldquo;owned&rdquo; pointer, or a &ldquo;box&rdquo;. While it can hand
out references to the contained data, it is the only owner of the data. In particular, consider
the following:
```rust
let x = Box::new(1);
@ -40,7 +40,7 @@ allowed to share references to this by the regular borrowing rules, checked at c
[box]: ../std/boxed/struct.Box.html
## `&T` and `&mut T`
## `&T` and `&mut T`
These are immutable and mutable references respectively. They follow the &ldquo;read-write lock&rdquo;
pattern, such that one may either have only one mutable reference to some data, or any number of
@ -243,7 +243,7 @@ Many of the types above cannot be used in a threadsafe manner. Particularly, `Rc
`RefCell<T>`, which both use non-atomic reference counts (_atomic_ reference counts are those which
can be incremented from multiple threads without causing a data race), cannot be used this way. This
makes them cheaper to use, but we need thread safe versions of these too. They exist, in the form of
`Arc<T>` and `Mutex<T>`/`RWLock<T>`
`Arc<T>` and `Mutex<T>`/`RwLock<T>`
Note that the non-threadsafe types _cannot_ be sent between threads, and this is checked at compile
time.

10
src/doc/trpl/deref-coercions.md
View File

@ -89,8 +89,8 @@ Vectors can `Deref` to a slice.
## Deref and method calls
`Deref` will also kick in when calling a method. In other words, these are
the same two things in Rust:
`Deref` will also kick in when calling a method. Consider the following
example.
```rust
struct Foo;
@ -99,13 +99,13 @@ impl Foo {
fn foo(&self) { println!("Foo"); }
}
let f = Foo;
let f = &&Foo;
f.foo();
```
Even though `f` isn’t a reference, and `foo` takes `&self`, this works.
That’s because these things are the same:
Even though `f` is a `&&Foo` and `foo` takes `&self`, this works. That’s
because these things are the same:
```rust,ignore
f.foo();

4
src/doc/trpl/the-stack-and-the-heap.md
View File

@ -38,7 +38,7 @@ local variables and some other information. This is called a ‘stack frame’,
for the purpose of this tutorial, we’re going to ignore the extra information
and just consider the local variables we’re allocating. So in this case, when
`main()` is run, we’ll allocate a single 32-bit integer for our stack frame.
This is automatically handled for you, as you can see, we didn’t have to write
This is automatically handled for you, as you can see; we didn’t have to write
any special Rust code or anything.
When the function is over, its stack frame gets deallocated. This happens
@ -51,7 +51,7 @@ we’ll throw them all away at the same time as well, we can get rid of it very
fast too.
The downside is that we can’t keep values around if we need them for longer
than a single function. We also haven’t talked about what that name, ‘stack’
than a single function. We also haven’t talked about what the word, ‘stack’,
means. To do that, we need a slightly more complicated example:
```rust

8
src/grammar/RustLexer.g4
View File

@ -13,8 +13,8 @@ tokens {
BINOPEQ, AT, DOT, DOTDOT, DOTDOTDOT, COMMA, SEMI, COLON,
MOD_SEP, RARROW, FAT_ARROW, LPAREN, RPAREN, LBRACKET, RBRACKET,
LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR, LIT_BYTE,
LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BINARY,
LIT_BINARY_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BYTE_STR,
LIT_BYTE_STR_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
COMMENT, SHEBANG, UTF8_BOM
}
@ -148,8 +148,8 @@ LIT_STR
: '"' ('\\\n' | '\\\r\n' | '\\' CHAR_ESCAPE | .)*? '"' SUFFIX?
;
LIT_BINARY : 'b' LIT_STR ;
LIT_BINARY_RAW : 'b' LIT_STR_RAW ;
LIT_BYTE_STR : 'b' LIT_STR ;
LIT_BYTE_STR_RAW : 'b' LIT_STR_RAW ;
/* this is a bit messy */

8
src/grammar/lexer.l
View File

@ -200,7 +200,7 @@ while { return WHILE; }
<ltorchar><<EOF>> { BEGIN(INITIAL); return -1; }
b\x22 { BEGIN(bytestr); yymore(); }
<bytestr>\x22 { BEGIN(suffix); return LIT_BINARY; }
<bytestr>\x22 { BEGIN(suffix); return LIT_BYTE_STR; }
<bytestr><<EOF>> { return -1; }
<bytestr>\\[n\nrt\\\x27\x220] { yymore(); }
@ -210,7 +210,7 @@ b\x22 { BEGIN(bytestr); yymore(); }
<bytestr>(.|\n) { yymore(); }
br\x22 { BEGIN(rawbytestr_nohash); yymore(); }
<rawbytestr_nohash>\x22 { BEGIN(suffix); return LIT_BINARY_RAW; }
<rawbytestr_nohash>\x22 { BEGIN(suffix); return LIT_BYTE_STR_RAW; }
<rawbytestr_nohash>(.|\n) { yymore(); }
<rawbytestr_nohash><<EOF>> { return -1; }
@ -228,7 +228,7 @@ br/# {
end_hashes++;
if (end_hashes == num_hashes) {
BEGIN(INITIAL);
return LIT_BINARY_RAW;
return LIT_BYTE_STR_RAW;
}
}
yymore();
@ -237,7 +237,7 @@ br/# {
end_hashes = 1;
if (end_hashes == num_hashes) {
BEGIN(INITIAL);
return LIT_BINARY_RAW;
return LIT_BYTE_STR_RAW;
}
yymore();
}

12
src/grammar/parser-lalr.y
View File

@ -52,8 +52,8 @@ extern char *yytext;
%token LIT_FLOAT
%token LIT_STR
%token LIT_STR_RAW
%token LIT_BINARY
%token LIT_BINARY_RAW
%token LIT_BYTE_STR
%token LIT_BYTE_STR_RAW
%token IDENT
%token UNDERSCORE
%token LIFETIME
@ -1772,8 +1772,8 @@ lit
str
: LIT_STR { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("CookedStr")); }
| LIT_STR_RAW { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("RawStr")); }
| LIT_BINARY { $$ = mk_node("LitBinary", 1, mk_atom(yytext), mk_atom("BinaryStr")); }
| LIT_BINARY_RAW { $$ = mk_node("LitBinary", 1, mk_atom(yytext), mk_atom("RawBinaryStr")); }
| LIT_BYTE_STR { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("ByteStr")); }
| LIT_BYTE_STR_RAW { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("RawByteStr")); }
;
maybe_ident
@ -1815,8 +1815,8 @@ unpaired_token
| LIT_FLOAT { $$ = mk_atom(yytext); }
| LIT_STR { $$ = mk_atom(yytext); }
| LIT_STR_RAW { $$ = mk_atom(yytext); }
| LIT_BINARY { $$ = mk_atom(yytext); }
| LIT_BINARY_RAW { $$ = mk_atom(yytext); }
| LIT_BYTE_STR { $$ = mk_atom(yytext); }
| LIT_BYTE_STR_RAW { $$ = mk_atom(yytext); }
| IDENT { $$ = mk_atom(yytext); }
| UNDERSCORE { $$ = mk_atom(yytext); }
| LIFETIME { $$ = mk_atom(yytext); }

4
src/grammar/tokens.h
View File

@ -38,8 +38,8 @@ enum Token {
LIT_FLOAT,
LIT_STR,
LIT_STR_RAW,
LIT_BINARY,
LIT_BINARY_RAW,
LIT_BYTE_STR,
LIT_BYTE_STR_RAW,
IDENT,
UNDERSCORE,
LIFETIME,

16
src/grammar/verify.rs
View File

@ -107,8 +107,8 @@ fn parse_token_list(file: &str) -> HashMap<String, token::Token> {
"OR" => token::BinOp(token::Or),
"GT" => token::Gt,
"LE" => token::Le,
"LIT_BINARY" => token::Literal(token::Binary(Name(0)), None),
"LIT_BINARY_RAW" => token::Literal(token::BinaryRaw(Name(0), 0), None),
"LIT_BYTE_STR" => token::Literal(token::ByteStr(Name(0)), None),
"LIT_BYTE_STR_RAW" => token::Literal(token::ByteStrRaw(Name(0), 0), None),
"QUESTION" => token::Question,
"SHEBANG" => token::Shebang(Name(0)),
_ => continue,
@ -137,8 +137,8 @@ fn str_to_binop(s: &str) -> token::BinOpToken {
}
}
/// Assuming a string/binary literal, strip out the leading/trailing
/// hashes and surrounding quotes/raw/binary prefix.
/// Assuming a string/byte string literal, strip out the leading/trailing
/// hashes and surrounding quotes/raw/byte prefix.
fn fix(mut lit: &str) -> ast::Name {
if lit.char_at(0) == 'r' {
if lit.char_at(1) == 'b' {
@ -205,8 +205,8 @@ fn parse_antlr_token(s: &str, tokens: &HashMap<String, token::Token>, surrogate_
token::DocComment(..) => token::DocComment(nm),
token::Literal(token::Integer(..), n) => token::Literal(token::Integer(nm), n),
token::Literal(token::Float(..), n) => token::Literal(token::Float(nm), n),
token::Literal(token::Binary(..), n) => token::Literal(token::Binary(nm), n),
token::Literal(token::BinaryRaw(..), n) => token::Literal(token::BinaryRaw(fix(content),
token::Literal(token::ByteStr(..), n) => token::Literal(token::ByteStr(nm), n),
token::Literal(token::ByteStrRaw(..), n) => token::Literal(token::ByteStrRaw(fix(content),
count(content)), n),
token::Ident(..) => token::Ident(ast::Ident { name: nm, ctxt: 0 },
token::ModName),
@ -340,8 +340,8 @@ fn main() {
token::Literal(token::Float(..), _),
token::Literal(token::Str_(..), _),
token::Literal(token::StrRaw(..), _),
token::Literal(token::Binary(..), _),
token::Literal(token::BinaryRaw(..), _),
token::Literal(token::ByteStr(..), _),
token::Literal(token::ByteStrRaw(..), _),
token::Ident(..),
token::Lifetime(..),
token::Interpolated(..),

14
src/liballoc/rc.rs
View File

@ -51,7 +51,7 @@
//! fn main() {
//! // Create a reference counted Owner.
//! let gadget_owner : Rc<Owner> = Rc::new(
//! Owner { name: String::from("Gadget Man") }
//! Owner { name: String::from("Gadget Man") }
//! );
//!
//! // Create Gadgets belonging to gadget_owner. To increment the reference
@ -102,13 +102,13 @@
//!
//! struct Owner {
//! name: String,
//! gadgets: RefCell<Vec<Weak<Gadget>>>
//! gadgets: RefCell<Vec<Weak<Gadget>>>,
//! // ...other fields
//! }
//!
//! struct Gadget {
//! id: i32,
//! owner: Rc<Owner>
//! owner: Rc<Owner>,
//! // ...other fields
//! }
//!
@ -117,10 +117,10 @@
//! // Owner's vector of Gadgets inside a RefCell so that we can mutate it
//! // through a shared reference.
//! let gadget_owner : Rc<Owner> = Rc::new(
//! Owner {
//! name: "Gadget Man".to_string(),
//! gadgets: RefCell::new(Vec::new())
//! }
//! Owner {
//! name: "Gadget Man".to_string(),
//! gadgets: RefCell::new(Vec::new()),
//! }
//! );
//!
//! // Create Gadgets belonging to gadget_owner as before.

10
src/librustc/middle/const_eval.rs
View File

@ -269,7 +269,7 @@ pub enum ConstVal {
Int(i64),
Uint(u64),
Str(InternedString),
Binary(Rc<Vec<u8>>),
ByteStr(Rc<Vec<u8>>),
Bool(bool),
Struct(ast::NodeId),
Tuple(ast::NodeId),
@ -283,7 +283,7 @@ impl ConstVal {
Int(_) => "positive integer",
Uint(_) => "unsigned integer",
Str(_) => "string literal",
Binary(_) => "binary array",
ByteStr(_) => "byte string literal",
Bool(_) => "boolean",
Struct(_) => "struct",
Tuple(_) => "tuple",
@ -1175,8 +1175,8 @@ fn cast_const<'tcx>(tcx: &ty::ctxt<'tcx>, val: ConstVal, ty: Ty) -> CastResult {
fn lit_to_const(lit: &hir::Lit, ty_hint: Option<Ty>) -> ConstVal {
match lit.node {
hir::LitStr(ref s, _) => Str((*s).clone()),
hir::LitBinary(ref data) => {
Binary(data.clone())
hir::LitByteStr(ref data) => {
ByteStr(data.clone())
}
hir::LitByte(n) => Uint(n as u64),
hir::LitChar(n) => Uint(n as u64),
@ -1214,7 +1214,7 @@ pub fn compare_const_vals(a: &ConstVal, b: &ConstVal) -> Option<Ordering> {
}
(&Str(ref a), &Str(ref b)) => a.cmp(b),
(&Bool(a), &Bool(b)) => a.cmp(&b),
(&Binary(ref a), &Binary(ref b)) => a.cmp(b),
(&ByteStr(ref a), &ByteStr(ref b)) => a.cmp(b),
_ => return None
})
}

2
src/librustc_front/hir.rs
View File

@ -838,7 +838,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/librustc_front/lowering.rs
View File

@ -664,7 +664,7 @@ pub fn lower_lit(l: &Lit) -> hir::Lit {
Spanned {
node: match l.node {
LitStr(ref i, s) => hir::LitStr(i.clone(), lower_string_style(s)),
LitBinary(ref b) => hir::LitBinary(b.clone()),
LitByteStr(ref b) => hir::LitByteStr(b.clone()),
LitByte(u) => hir::LitByte(u),
LitChar(c) => hir::LitChar(c),
LitInt(u, ref t) => hir::LitInt(u, lower_lit_int_type(t)),
@ -680,7 +680,7 @@ pub fn unlower_lit(l: &hir::Lit) -> Lit {
Spanned {
node: match l.node {
hir::LitStr(ref i, s) => LitStr(i.clone(), unlower_string_style(s)),
hir::LitBinary(ref b) => LitBinary(b.clone()),
hir::LitByteStr(ref b) => LitByteStr(b.clone()),
hir::LitByte(u) => LitByte(u),
hir::LitChar(c) => LitChar(c),
hir::LitInt(u, ref t) => LitInt(u, unlower_lit_int_type(t)),

2
src/librustc_front/print/pprust.rs
View File

@ -2549,7 +2549,7 @@ impl<'a> State<'a> {
hir::LitBool(val) => {
if val { word(&mut self.s, "true") } else { word(&mut self.s, "false") }
}
hir::LitBinary(ref v) => {
hir::LitByteStr(ref v) => {
let mut escaped: String = String::new();
for &ch in v.iter() {
escaped.extend(ascii::escape_default(ch)

4
src/librustc_trans/trans/consts.rs
View File

@ -94,8 +94,8 @@ pub fn const_lit(cx: &CrateContext, e: &hir::Expr, lit: &hir::Lit)
}
hir::LitBool(b) => C_bool(cx, b),
hir::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()),
hir::LitBinary(ref data) => {
addr_of(cx, C_bytes(cx, &data[..]), "binary")
hir::LitByteStr(ref data) => {
addr_of(cx, C_bytes(cx, &data[..]), "byte_str")
}
}
}

2
src/librustc_typeck/check/_match.rs
View File

@ -56,7 +56,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
// They can denote both statically and dynamically sized byte arrays
let mut pat_ty = expr_ty;
if let hir::ExprLit(ref lt) = lt.node {
if let hir::LitBinary(_) = lt.node {
if let hir::LitByteStr(_) = lt.node {
let expected_ty = structurally_resolved_type(fcx, pat.span, expected);
if let ty::TyRef(_, mt) = expected_ty.sty {
if let ty::TySlice(_) = mt.ty.sty {

2
src/librustc_typeck/check/mod.rs
View File

@ -2633,7 +2633,7 @@ fn check_lit<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
match lit.node {
hir::LitStr(..) => tcx.mk_static_str(),
hir::LitBinary(ref v) => {
hir::LitByteStr(ref v) => {
tcx.mk_imm_ref(tcx.mk_region(ty::ReStatic),
tcx.mk_array(tcx.types.u8, v.len()))
}

2
src/librustdoc/clean/mod.rs
View File

@ -2518,7 +2518,7 @@ impl ToSource for syntax::codemap::Span {
fn lit_to_string(lit: &hir::Lit) -> String {
match lit.node {
hir::LitStr(ref st, _) => st.to_string(),
hir::LitBinary(ref data) => format!("{:?}", data),
hir::LitByteStr(ref data) => format!("{:?}", data),
hir::LitByte(b) => {
let mut res = String::from("b'");
for c in (b as char).escape_default() {

2
src/librustdoc/html/highlight.rs
View File

@ -131,7 +131,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader,
match lit {
// text literals
token::Byte(..) | token::Char(..) |
token::Binary(..) | token::BinaryRaw(..) |
token::ByteStr(..) | token::ByteStrRaw(..) |
token::Str_(..) | token::StrRaw(..) => "string",
// number literals

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)

4
src/test/compile-fail/concat.rs
View File

@ -9,8 +9,8 @@
// except according to those terms.
fn main() {
concat!(b'f'); //~ ERROR: cannot concatenate a binary literal
concat!(b"foo"); //~ ERROR: cannot concatenate a binary literal
concat!(b'f'); //~ ERROR: cannot concatenate a byte string literal
concat!(b"foo"); //~ ERROR: cannot concatenate a byte string literal
concat!(foo); //~ ERROR: expected a literal
concat!(foo()); //~ ERROR: expected a literal
}

8
src/test/parse-fail/bad-lit-suffixes.rs
View File

@ -20,10 +20,10 @@ extern
{}
fn main() {
""suffix; //~ ERROR str literal with a suffix is invalid
b""suffix; //~ ERROR binary str literal with a suffix is invalid
r#""#suffix; //~ ERROR str literal with a suffix is invalid
br#""#suffix; //~ ERROR binary str literal with a suffix is invalid
""suffix; //~ ERROR string literal with a suffix is invalid
b""suffix; //~ ERROR byte string literal with a suffix is invalid
r#""#suffix; //~ ERROR string literal with a suffix is invalid
br#""#suffix; //~ ERROR byte string literal with a suffix is invalid
'a'suffix; //~ ERROR char literal with a suffix is invalid
b'a'suffix; //~ ERROR byte literal with a suffix is invalid

2
src/test/run-make/symbols-are-reasonable/Makefile
View File

@ -11,5 +11,5 @@ all:
$(RUSTC) lib.rs --emit=asm --crate-type=staticlib
# just check for symbol declarations with the names we're expecting.
grep 'str[0-9][0-9]*:' $(OUT)
grep 'binary[0-9][0-9]*:' $(OUT)
grep 'byte_str[0-9][0-9]*:' $(OUT)
grep 'vtable[0-9][0-9]*' $(OUT)