---

yaml
---
r: 83758
b: refs/heads/try
c: b17dc4a
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 97878725532c4d1dd1af07e88175462178d78cdb
+refs/heads/try: b17dc4a946838a7f0a1d8eb752536243e322e8de
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -239,14 +239,13 @@ literal : string_lit | char_lit | num_lit ;
 
 ~~~~~~~~ {.ebnf .gram}
 char_lit : '\x27' char_body '\x27' ;
-string_lit : '"' string_body * '"' | 'r' raw_string ;
+string_lit : '"' string_body * '"' ;
 
 char_body : non_single_quote
           | '\x5c' [ '\x27' | common_escape ] ;
 
 string_body : non_double_quote
             | '\x5c' [ '\x22' | common_escape ] ;
-raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
 
 common_escape : '\x5c'
               | 'n' | 'r' | 't' | '0'
@@ -268,10 +267,9 @@ which must be _escaped_ by a preceding U+005C character (`\`).
 
 A _string literal_ is a sequence of any Unicode characters enclosed within
 two `U+0022` (double-quote) characters, with the exception of `U+0022`
-itself, which must be _escaped_ by a preceding `U+005C` character (`\`),
-or a _raw string literal_.
+itself, which must be _escaped_ by a preceding `U+005C` character (`\`).
 
-Some additional _escapes_ are available in either character or non-raw string
+Some additional _escapes_ are available in either character or string
 literals. An escape starts with a `U+005C` (`\`) and continues with one of
 the following forms:
 
@@ -287,35 +285,9 @@ the following forms:
   * A _whitespace escape_ is one of the characters `U+006E` (`n`), `U+0072`
     (`r`), or `U+0074` (`t`), denoting the unicode values `U+000A` (LF),
     `U+000D` (CR) or `U+0009` (HT) respectively.
-  * The _backslash escape_ is the character `U+005C` (`\`) which must be
+  * The _backslash escape_ is the character U+005C (`\`) which must be
     escaped in order to denote *itself*.
 
-Raw string literals do not process any escapes. They start with the character
-`U+0072` (`r`), followed zero or more of the character `U+0023` (`#`) and a
-`U+0022` (double-quote) character. The _raw string body_ is not defined in the
-EBNF grammar above: it can contain any sequence of Unicode characters and is
-terminated only by another `U+0022` (double-quote) character, followed by the
-same number of `U+0023` (`#`) characters that preceeded the opening `U+0022`
-(double-quote) character.
-
-All Unicode characters contained in the raw string body represent themselves,
-the characters `U+0022` (double-quote) (except when followed by at least as
-many `U+0023` (`#`) characters as were used to start the raw string literal) or
-`U+005C` (`\`) do not have any special meaning.
-
-Examples for string literals:
-
-~~~
-"foo"; r"foo";                     // foo
-"\"foo\""; r#""foo""#;             // "foo"
-
-"foo #\"# bar";
-r##"foo #"# bar"##;                // foo #"# bar
-
-"\x52"; "R"; r"R";                 // R
-"\\x52"; r"\x52";                  // \x52
-~~~
-
 #### Number literals
 
 ~~~~~~~~ {.ebnf .gram}

branches/try/doc/tutorial.md

@@ -353,12 +353,7 @@ whose literals are written between single quotes, as in `'x'`.
 Just like C, Rust understands a number of character escapes, using the backslash
 character, such as `\n`, `\r`, and `\t`. String literals,
 written between double quotes, allow the same escape sequences.
-
-On the other hand, raw string literals do not process any escape sequences.
-They are written as `r##"blah"##`, with a matching number of zero or more `#`
-before the opening and after the closing quote, and can contain any sequence of
-characters except their closing delimiter.  More on strings
-[later](#vectors-and-strings).
+More on strings [later](#vectors-and-strings).
 
 The nil type, written `()`, has a single value, also written `()`.
 

branches/try/src/etc/vim/syntax/rust.vim

@@ -148,7 +148,6 @@ syn match     rustFormat      display "%%" contained
 syn match     rustSpecial     display contained /\\\([nrt\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
 syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo,rustFormat,rustSpecial,rustStringContinuation
-syn region    rustString      start='r\z(#*\)"' end='"\z1'
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString,rustDeriving
 syn region    rustDeriving    start="deriving(" end=")" contained contains=rustTrait

branches/try/src/librustc/middle/trans/glue.rs

@@ -423,7 +423,6 @@ pub fn trans_struct_drop_flag(bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did:
             bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
         }
 
-        Store(bcx, C_u8(0), drop_flag);
         bcx
     }
 }
@@ -595,23 +594,6 @@ pub fn make_take_glue(bcx: @mut Block, v: ValueRef, t: ty::t) -> @mut Block {
           bcx
       }
       ty::ty_opaque_closure_ptr(_) => bcx,
-      ty::ty_struct(did, _) => {
-        let tcx = bcx.tcx();
-        let bcx = iter_structural_ty(bcx, v, t, take_ty);
-
-        match ty::ty_dtor(tcx, did) {
-          ty::TraitDtor(_, false) => {
-            // Zero out the struct
-            unsafe {
-                let ty = Type::from_ref(llvm::LLVMTypeOf(v));
-                memzero(&B(bcx), v, ty);
-            }
-
-          }
-          _ => { }
-        }
-        bcx
-      }
       _ if ty::type_is_structural(t) => {
         iter_structural_ty(bcx, v, t, take_ty)
       }

branches/try/src/libsyntax/ext/base.rs

@@ -437,8 +437,7 @@ pub fn get_single_str_from_tts(cx: @ExtCtxt,
     }
 
     match tts[0] {
-        ast::tt_tok(_, token::LIT_STR(ident))
-        | ast::tt_tok(_, token::LIT_STR_RAW(ident, _)) => cx.str_of(ident),
+        ast::tt_tok(_, token::LIT_STR(ident)) => cx.str_of(ident),
         _ => cx.span_fatal(sp, format!("{} requires a string.", name)),
     }
 }

branches/try/src/libsyntax/ext/quote.rs

@@ -464,13 +464,6 @@ fn mk_token(cx: @ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
                                       ~[mk_ident(cx, sp, ident)]);
         }
 
-        LIT_STR_RAW(ident, n) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_STR_RAW"),
-                                      ~[mk_ident(cx, sp, ident),
-                                        cx.expr_uint(sp, n)]);
-        }
-
         IDENT(ident, b) => {
             return cx.expr_call_ident(sp,
                                       id_ext("IDENT"),

branches/try/src/libsyntax/parse/lexer.rs

@@ -213,22 +213,10 @@ fn byte_offset(rdr: &StringReader, pos: BytePos) -> BytePos {
     (pos - rdr.filemap.start_pos)
 }
 
-/// Calls `f` with a string slice of the source text spanning from `start`
-/// up to but excluding `rdr.last_pos`, meaning the slice does not include
-/// the character `rdr.curr`.
 pub fn with_str_from<T>(rdr: @mut StringReader, start: BytePos, f: &fn(s: &str) -> T) -> T {
-    with_str_from_to(rdr, start, rdr.last_pos, f)
-}
-
-/// Calls `f` with astring slice of the source text spanning from `start`
-/// up to but excluding `end`.
-fn with_str_from_to<T>(rdr: @mut StringReader,
-                       start: BytePos,
-                       end: BytePos,
-                       f: &fn(s: &str) -> T) -> T {
     f(rdr.src.slice(
             byte_offset(rdr, start).to_uint(),
-            byte_offset(rdr, end).to_uint()))
+            byte_offset(rdr, rdr.last_pos).to_uint()))
 }
 
 // EFFECT: advance the StringReader by one character. If a newline is
@@ -624,10 +612,7 @@ fn ident_continue(c: char) -> bool {
 // EFFECT: updates the interner
 fn next_token_inner(rdr: @mut StringReader) -> token::Token {
     let c = rdr.curr;
-    if ident_start(c) && nextch(rdr) != '"' && nextch(rdr) != '#' {
-        // Note: r as in r" or r#" is part of a raw string literal,
-        // not an identifier, and is handled further down.
-
+    if ident_start(c) {
         let start = rdr.last_pos;
         while ident_continue(rdr.curr) {
             bump(rdr);
@@ -844,47 +829,6 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
         bump(rdr);
         return token::LIT_STR(str_to_ident(accum_str));
       }
-      'r' => {
-        let start_bpos = rdr.last_pos;
-        bump(rdr);
-        let mut hash_count = 0u;
-        while rdr.curr == '#' {
-            bump(rdr);
-            hash_count += 1;
-        }
-        if rdr.curr != '"' {
-            fatal_span_char(rdr, start_bpos, rdr.last_pos,
-                            ~"only `#` is allowed in raw string delimitation; \
-                              found illegal character",
-                            rdr.curr);
-        }
-        bump(rdr);
-        let content_start_bpos = rdr.last_pos;
-        let mut content_end_bpos;
-        'outer: loop {
-            if is_eof(rdr) {
-                fatal_span(rdr, start_bpos, rdr.last_pos,
-                           ~"unterminated raw string");
-            }
-            if rdr.curr == '"' {
-                content_end_bpos = rdr.last_pos;
-                for _ in range(0, hash_count) {
-                    bump(rdr);
-                    if rdr.curr != '#' {
-                        continue 'outer;
-                    }
-                }
-                break;
-            }
-            bump(rdr);
-        }
-        bump(rdr);
-        let str_content = with_str_from_to(rdr,
-                                           content_start_bpos,
-                                           content_end_bpos,
-                                           str_to_ident);
-        return token::LIT_STR_RAW(str_content, hash_count);
-      }
       '-' => {
         if nextch(rdr) == '>' {
             bump(rdr);
@@ -1043,14 +987,6 @@ mod test {
         assert_eq!(tok, token::LIFETIME(id));
     }
 
-    #[test] fn raw_string() {
-        let env = setup(@"r###\"\"#a\\b\x00c\"\"###");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        let id = token::str_to_ident("\"#a\\b\x00c\"");
-        assert_eq!(tok, token::LIT_STR_RAW(id, 3));
-    }
-
     #[test] fn line_doc_comments() {
         assert!(!is_line_non_doc_comment("///"));
         assert!(!is_line_non_doc_comment("/// blah"));

branches/try/src/libsyntax/parse/parser.rs

@@ -1283,7 +1283,6 @@ impl Parser {
             token::LIT_FLOAT_UNSUFFIXED(s) =>
                 lit_float_unsuffixed(self.id_to_str(s)),
             token::LIT_STR(s) => lit_str(self.id_to_str(s)),
-            token::LIT_STR_RAW(s, _) => lit_str(self.id_to_str(s)),
             token::LPAREN => { self.expect(&token::RPAREN); lit_nil },
             _ => { self.unexpected_last(tok); }
         }
@@ -4346,8 +4345,7 @@ impl Parser {
     // parse a string as an ABI spec on an extern type or module
     fn parse_opt_abis(&self) -> Option<AbiSet> {
         match *self.token {
-            token::LIT_STR(s)
-            | token::LIT_STR_RAW(s, _) => {
+            token::LIT_STR(s) => {
                 self.bump();
                 let the_string = ident_to_str(&s);
                 let mut abis = AbiSet::empty();
@@ -4934,8 +4932,7 @@ impl Parser {
 
     pub fn parse_optional_str(&self) -> Option<@str> {
         match *self.token {
-            token::LIT_STR(s)
-            | token::LIT_STR_RAW(s, _) => {
+            token::LIT_STR(s) => {
                 self.bump();
                 Some(ident_to_str(&s))
             }

branches/try/src/libsyntax/parse/token.rs

@@ -79,7 +79,6 @@ pub enum Token {
     LIT_FLOAT(ast::Ident, ast::float_ty),
     LIT_FLOAT_UNSUFFIXED(ast::Ident),
     LIT_STR(ast::Ident),
-    LIT_STR_RAW(ast::Ident, uint), /* raw str delimited by n hash symbols */
 
     /* Name components */
     // an identifier contains an "is_mod_name" boolean,
@@ -195,10 +194,6 @@ pub fn to_str(input: @ident_interner, t: &Token) -> ~str {
         body
       }
       LIT_STR(ref s) => { format!("\"{}\"", ident_to_str(s).escape_default()) }
-      LIT_STR_RAW(ref s, n) => {
-          format!("r{delim}\"{string}\"{delim}",
-                  delim="#".repeat(n), string=ident_to_str(s))
-      }
 
       /* Name components */
       IDENT(s, _) => input.get(s.name).to_owned(),
@@ -248,7 +243,6 @@ pub fn can_begin_expr(t: &Token) -> bool {
       LIT_FLOAT(_, _) => true,
       LIT_FLOAT_UNSUFFIXED(_) => true,
       LIT_STR(_) => true,
-      LIT_STR_RAW(_, _) => true,
       POUND => true,
       AT => true,
       NOT => true,
@@ -290,7 +284,6 @@ pub fn is_lit(t: &Token) -> bool {
       LIT_FLOAT(_, _) => true,
       LIT_FLOAT_UNSUFFIXED(_) => true,
       LIT_STR(_) => true,
-      LIT_STR_RAW(_, _) => true,
       _ => false
     }
 }

branches/try/src/libsyntax/print/pprust.rs

@@ -1895,9 +1895,7 @@ pub fn print_view_item(s: @ps, item: &ast::view_item) {
             head(s, "extern mod");
             print_ident(s, id);
             for p in optional_path.iter() {
-                space(s.s);
                 word(s.s, "=");
-                space(s.s);
                 print_string(s, *p);
             }
             if !mta.is_empty() {