---

yaml
---
r: 92090
b: refs/heads/auto
c: 9d64e46
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5fa6bd526ef66ce9ce80e975340aa98bcc3596b7
+refs/heads/auto: 9d64e46013096997627da62ecc65225bc22682e8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/procsrv.rs

@@ -60,12 +60,12 @@ pub fn run(lib_path: &str,
     for input in input.iter() {
         process.input().write(input.as_bytes());
     }
-    let output = process.finish_with_output();
+    let run::ProcessOutput { status, output, error } = process.finish_with_output();
 
     Result {
-        status: output.status,
-        out: str::from_utf8(output.output),
-        err: str::from_utf8(output.error)
+        status: status,
+        out: str::from_utf8_owned(output),
+        err: str::from_utf8_owned(error)
     }
 }
 
@@ -90,4 +90,3 @@ pub fn run_background(lib_path: &str,
 
     return process;
 }
-

branches/auto/src/compiletest/runtest.rs

@@ -298,7 +298,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
 
                 let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
                          config.adb_test_dir.clone(), config.adb_test_dir.clone(),
-                         str::from_utf8(exe_file.filename().unwrap())).clone();
+                         str::from_utf8_slice(exe_file.filename().unwrap()));
 
                 let mut process = procsrv::run_background("", config.adb_path.clone(),
                         [~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""));
@@ -1151,4 +1151,3 @@ fn run_codegen_test(config: &config, props: &TestProps,
                      (base_lines as f64) / (clang_lines as f64),
                      0.001);
 }
-

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

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2013 Dec 04
+" Last Change:  2013 Oct 29
 
 if version < 600
   syntax clear
@@ -28,7 +28,6 @@ syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite
-syn keyword   rustKeyword     proc
 syn keyword   rustStorage     const mut ref static
 
 syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
@@ -90,7 +89,6 @@ syn keyword rustTrait Orderable Signed Unsigned Round
 syn keyword rustTrait Primitive Int Float ToStrRadix ToPrimitive FromPrimitive
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath
 syn keyword rustTrait RawPtr
-syn keyword rustTrait Buffer Writer Reader Seek
 syn keyword rustTrait SendStr SendStrOwned SendStrStatic IntoSendStr
 syn keyword rustTrait Str StrVector StrSlice OwnedStr
 syn keyword rustTrait IterBytes
@@ -145,29 +143,38 @@ syn match     rustOperator     display "&&\|||"
 syn match     rustMacro       '\w\(\w\)*!' contains=rustAssert,rustFail
 syn match     rustMacro       '#\w\(\w\)*' contains=rustAssert,rustFail
 
-syn match     rustSpecialError display contained /\\./
+syn match     rustFormat      display "%\(\d\+\$\)\=[-+' #0*]*\(\d*\|\*\|\*\d\+\$\)\(\.\(\d*\|\*\|\*\d\+\$\)\)\=\([hlLjzt]\|ll\|hh\)\=\([aAbdiuoxXDOUfFeEgGcCsSpn?]\|\[\^\=.[^]]*\]\)" contained
+syn match     rustFormat      display "%%" contained
 syn match     rustSpecial     display contained /\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
-syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation
+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
 
 " Number literals
-syn match     rustDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustOctNumber   display "\<0o[0-7_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustBinNumber   display "\<0b[01_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-
-" To mark it as a float, it must have at least one of the three things integral values don't have:
-" a decimal point and more numbers; an exponent; and a type suffix.
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\="
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\="
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)"
-" Special case for numbers of the form "1." which are float literals, unless followed by
-" an identifier, which makes them integer literals with a method call or field access.
-syn match     rustFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\@!"
+syn match     rustNumber      display "\<[0-9][0-9_]*\>"
+syn match     rustNumber      display "\<[0-9][0-9_]*\(u\|u8\|u16\|u32\|u64\)\>"
+syn match     rustNumber      display "\<[0-9][0-9_]*\(i\|i8\|i16\|i32\|i64\)\>"
+
+syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\>"
+syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\(u\|u8\|u16\|u32\|u64\)\>"
+syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\(i8\|i16\|i32\|i64\)\>"
+syn match     rustOctNumber   display "\<0o[0-7_]\+\>"
+syn match     rustOctNumber   display "\<0o[0-7_]\+\(u\|u8\|u16\|u32\|u64\)\>"
+syn match     rustOctNumber   display "\<0o[0-7_]\+\(i8\|i16\|i32\|i64\)\>"
+syn match     rustBinNumber   display "\<0b[01_]\+\>"
+syn match     rustBinNumber   display "\<0b[01_]\+\(u\|u8\|u16\|u32\|u64\)\>"
+syn match     rustBinNumber   display "\<0b[01_]\+\(i8\|i16\|i32\|i64\)\>"
+
+syn match     rustFloat       display "\<[0-9][0-9_]*\(f\|f32\|f64\)\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\([eE][+-]\=[0-9_]\+\)\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\([eE][+-]\=[0-9_]\+\)\(f\|f32\|f64\)\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\.[0-9_]\+\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\.[0-9_]\+\(f\|f32\|f64\)\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\.[0-9_]\+\%([eE][+-]\=[0-9_]\+\)\>"
+syn match     rustFloat       display "\<[0-9][0-9_]*\.[0-9_]\+\%([eE][+-]\=[0-9_]\+\)\(f\|f32\|f64\)\>"
 
 " For the benefit of delimitMate
 syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
@@ -176,24 +183,12 @@ syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[
 
 "rustLifetime must appear before rustCharacter, or chars will get the lifetime highlighting
 syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
-syn match   rustCharacter   /'\([^'\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial,rustSpecialError
-
-syn cluster rustComment contains=rustCommentLine,rustCommentLineDoc,rustCommentBlock,rustCommentBlockDoc
-syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo
-syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo
-syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment keepend extend
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment keepend extend
-" FIXME: this is a really ugly and not fully correct implementation. Most
-" importantly, a case like ``/* */*`` should have the final ``*`` not being in
-" a comment, but in practice at present it leaves comments open two levels
-" deep. But as long as you stay away from that particular case, I *believe*
-" the highlighting is correct. Due to the way Vim's syntax engine works
-" (greedy for start matches, unlike Rust's tokeniser which is searching for
-" the earliest-starting match, start or end), I believe this cannot be solved.
-" Oh you who would fix it, don't bother with things like duplicating the Block
-" rules and putting ``\*\@<!`` at the start of them; it makes it worse, as
-" then you must deal with cases like ``/*/**/*/``. And don't try making it
-" worse with ``\%(/\@<!\*\)\@<!``, either...
+syn match   rustCharacter   /'\([^'\\]\|\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial
+
+syn region    rustCommentML   start="/\*" end="\*/" contains=rustTodo
+syn region    rustComment     start="//" end="$" contains=rustTodo keepend
+syn region    rustCommentMLDoc start="/\*\%(!\|\*[*/]\@!\)" end="\*/" contains=rustTodo
+syn region    rustCommentDoc  start="//\%(//\@!\|!\)" end="$" contains=rustTodo keepend
 
 syn keyword rustTodo contained TODO FIXME XXX NB NOTE
 
@@ -205,16 +200,15 @@ syn region rustFoldBraces start="{" end="}" transparent fold
 " It's not enabled by default as it would drive some people mad.
 
 " Default highlighting {{{1
-hi def link rustDecNumber       rustNumber
 hi def link rustHexNumber       rustNumber
 hi def link rustOctNumber       rustNumber
 hi def link rustBinNumber       rustNumber
 hi def link rustIdentifierPrime rustIdentifier
 hi def link rustTrait           rustType
 
 hi def link rustSigil         StorageClass
+hi def link rustFormat        Special
 hi def link rustSpecial       Special
-hi def link rustSpecialError  Error
 hi def link rustStringContinuation Special
 hi def link rustString        String
 hi def link rustCharacter     Character
@@ -235,10 +229,10 @@ hi def link rustModPathSep    Delimiter
 hi def link rustFunction      Function
 hi def link rustFuncName      Function
 hi def link rustFuncCall      Function
-hi def link rustCommentLine   Comment
-hi def link rustCommentLineDoc SpecialComment
-hi def link rustCommentBlock  rustCommentLine
-hi def link rustCommentBlockDoc rustCommentLineDoc
+hi def link rustCommentMLDoc  rustCommentDoc
+hi def link rustCommentDoc    SpecialComment
+hi def link rustCommentML     rustComment
+hi def link rustComment       Comment
 hi def link rustAssert        PreCondit
 hi def link rustFail          PreCondit
 hi def link rustMacro         Macro

branches/auto/src/libextra/base64.rs

@@ -162,7 +162,7 @@ impl<'self> FromBase64 for &'self str {
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_utf8` function in `std::str`
+     * You can use the `from_utf8_owned` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -180,7 +180,7 @@ impl<'self> FromBase64 for &'self str {
      *     println!("base64 output: {}", hello_str);
      *     let res = hello_str.from_base64();
      *     if res.is_ok() {
-     *       let optBytes = str::from_utf8_opt(res.unwrap());
+     *       let optBytes = str::from_utf8_owned_opt(res.unwrap());
      *       if optBytes.is_some() {
      *         println!("decoded from base64: {}", optBytes.unwrap());
      *       }

branches/auto/src/libextra/hex.rs

@@ -62,7 +62,7 @@ impl<'self> FromHex for &'self str {
      * Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_utf8` function in `std::str`
+     * You can use the `from_utf8_owned` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -80,7 +80,7 @@ impl<'self> FromHex for &'self str {
      *     println!("{}", hello_str);
      *     let bytes = hello_str.from_hex().unwrap();
      *     println!("{:?}", bytes);
-     *     let result_str = str::from_utf8(bytes);
+     *     let result_str = str::from_utf8_owned(bytes);
      *     println!("{}", result_str);
      * }
      * ```

branches/auto/src/libextra/terminfo/parser/compiled.rs

@@ -215,7 +215,9 @@ pub fn parse(file: &mut io::Reader,
         return Err(~"incompatible file: more string offsets than expected");
     }
 
-    let names_str = str::from_utf8(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
+    // don't read NUL
+    let names_str = str::from_utf8_owned(file.read_bytes(names_bytes as uint - 1));
+
     let term_names: ~[~str] = names_str.split('|').map(|s| s.to_owned()).collect();
 
     file.read_byte(); // consume NUL

branches/auto/src/libextra/test.rs

@@ -701,7 +701,7 @@ fn should_sort_failures_before_printing_them() {
 
     st.write_failures();
     let s = match st.out {
-        Right(ref m) => str::from_utf8(*m.inner_ref()),
+        Right(ref m) => str::from_utf8_slice(*m.inner_ref()),
         Left(_) => unreachable!()
     };
 

branches/auto/src/libextra/uuid.rs

@@ -310,7 +310,7 @@ impl Uuid {
             s[i*2+0] = digit[0];
             s[i*2+1] = digit[1];
         }
-        str::from_utf8(s)
+        str::from_utf8_owned(s)
     }
 
     /// Returns a string of hexadecimal digits, separated into groups with a hypen

branches/auto/src/libextra/workcache.rs

@@ -260,7 +260,7 @@ fn json_encode<'self, T:Encodable<json::Encoder<'self>>>(t: &T) -> ~str {
     let mut writer = MemWriter::new();
     let mut encoder = json::Encoder::init(&mut writer as &mut io::Writer);
     t.encode(&mut encoder);
-    str::from_utf8(writer.inner_ref().as_slice())
+    str::from_utf8_owned(writer.inner())
 }
 
 // FIXME(#5121)

branches/auto/src/librustc/back/archive.rs

@@ -41,8 +41,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
     let o = Process::new(ar, args.as_slice(), opts).finish_with_output();
     if !o.status.success() {
         sess.err(format!("{} failed with: {}", ar, o.status));
-        sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));
-        sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));
+        sess.note(format!("stdout ---\n{}", str::from_utf8_slice(o.output)));
+        sess.note(format!("stderr ---\n{}", str::from_utf8_slice(o.error)));
         sess.abort_if_errors();
     }
     o

branches/auto/src/librustc/back/link.rs

@@ -368,7 +368,7 @@ pub mod write {
         if !prog.status.success() {
             sess.err(format!("linking with `{}` failed: {}", cc, prog.status));
             sess.note(format!("{} arguments: '{}'", cc, args.connect("' '")));
-            sess.note(str::from_utf8(prog.error + prog.output));
+            sess.note(str::from_utf8_owned(prog.error + prog.output));
             sess.abort_if_errors();
         }
     }
@@ -1079,7 +1079,7 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path,
     if !prog.status.success() {
         sess.err(format!("linking with `{}` failed: {}", cc_prog, prog.status));
         sess.note(format!("{} arguments: '{}'", cc_prog, cc_args.connect("' '")));
-        sess.note(str::from_utf8(prog.error + prog.output));
+        sess.note(str::from_utf8_owned(prog.error + prog.output));
         sess.abort_if_errors();
     }
 

branches/auto/src/librustc/lib.rs

@@ -166,7 +166,7 @@ Available lint options:
         max_key = num::max(name.len(), max_key);
     }
     fn padded(max: uint, s: &str) -> ~str {
-        str::from_utf8(vec::from_elem(max - s.len(), ' ' as u8)) + s
+        " ".repeat(max - s.len()) + s
     }
     println("\nAvailable lint checks:\n");
     println!("    {}  {:7.7s}  {}",
@@ -246,7 +246,7 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
       1u => {
         let ifile = matches.free[0].as_slice();
         if "-" == ifile {
-            let src = str::from_utf8(io::stdin().read_to_end());
+            let src = str::from_utf8_owned(io::stdin().read_to_end());
             str_input(src.to_managed())
         } else {
             file_input(Path::init(ifile))

branches/auto/src/librustc/metadata/decoder.rs

@@ -1274,8 +1274,8 @@ fn family_names_type(fam: Family) -> bool {
 fn read_path(d: ebml::Doc) -> (~str, uint) {
     reader::with_doc_data(d, |desc| {
         let pos = u64_from_be_bytes(desc, 0u, 4u) as uint;
-        let pathbytes = desc.slice(4u, desc.len());
-        let path = str::from_utf8(pathbytes);
+        let pathbytes = desc.slice_from(4u).to_owned();
+        let path = str::from_utf8_owned(pathbytes);
 
         (path, pos)
     })

branches/auto/src/librustc/metadata/encoder.rs

@@ -1902,5 +1902,5 @@ pub fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str {
         abbrevs: tyencode::ac_no_abbrevs};
     let wr = @mut MemWriter::new();
     tyencode::enc_ty(wr, cx, t);
-    str::from_utf8(*wr.inner_ref())
+    str::from_utf8_owned(wr.inner_ref().to_owned())
 }

branches/auto/src/librustc/metadata/tydecode.rs

@@ -97,8 +97,9 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
 }
 
 fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident {
-    let rslt = scan(st, is_last, str::from_utf8);
-    return st.tcx.sess.ident_of(rslt);
+    scan(st, is_last, |bytes| {
+            st.tcx.sess.ident_of(str::from_utf8_slice(bytes))
+        })
 }
 
 pub fn parse_state_from_data<'a>(data: &'a [u8], crate_num: ast::CrateNum,
@@ -492,10 +493,11 @@ fn parse_abi_set(st: &mut PState) -> AbiSet {
     assert_eq!(next(st), '[');
     let mut abis = AbiSet::empty();
     while peek(st) != ']' {
-        // FIXME(#5422) str API should not force this copy
-        let abi_str = scan(st, |c| c == ',', str::from_utf8);
-        let abi = abi::lookup(abi_str).expect(abi_str);
-        abis.add(abi);
+         scan(st, |c| c == ',', |bytes| {
+                 let abi_str = str::from_utf8_slice(bytes).to_owned();
+                 let abi = abi::lookup(abi_str).expect(abi_str);
+                 abis.add(abi);
+              });
     }
     assert_eq!(next(st), ']');
     return abis;

branches/auto/src/librustc/metadata/tyencode.rs

@@ -72,7 +72,7 @@ pub fn enc_ty(w: @mut MemWriter, cx: @ctxt, t: ty::t) {
             None => {
                 let wr = @mut MemWriter::new();
                 enc_sty(wr, cx, &ty::get(t).sty);
-                let s = str::from_utf8(*wr.inner_ref()).to_managed();
+                let s = str::from_utf8_slice(*wr.inner_ref()).to_managed();
                 cx.tcx.short_names_cache.insert(t, s);
                 s
           }

branches/auto/src/librustc/middle/privacy.rs

@@ -243,7 +243,7 @@ impl<'self> Visitor<()> for EmbargoVisitor<'self> {
                             ast::sty_static => public_ty,
                             _ => true,
                         } && method.vis == ast::public;
-                        if meth_public || tr.is_some() {
+                        if meth_public || public_trait {
                             self.exported_items.insert(method.id);
                         }
                     }