---

yaml
---
r: 94064
b: refs/heads/try
c: 0cd79ee
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 1191ae87dbf301a26379ca1b9797c352ab082b85
+refs/heads/try: 0cd79ee18aa38339147516413679f6fdaf01ca1a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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/try/src/libextra/url.rs

@@ -19,51 +19,23 @@ use std::hashmap::HashMap;
 use std::to_bytes;
 use std::uint;
 
-/// A Uniform Resource Locator (URL).  A URL is a form of URI (Uniform Resource
-/// Identifier) that includes network location information, such as hostname or
-/// port number.
-///
-/// # Example
-///
-/// ```rust
-/// let url = Url { scheme: ~"https",
-///                 user: Some(UserInfo { user: ~"username", pass: None }),
-///                 host: ~"example.com",
-///                 port: Some(~"8080"),
-///                 path: ~"/foo/bar",
-///                 query: ~[(~"baz", ~"qux")],
-///                 fragment: Some(~"quz") };
-/// // https://[email protected]:8080/foo/bar?baz=qux#quz
-/// ```
 #[deriving(Clone, Eq)]
 pub struct Url {
-    /// The scheme part of a URL, such as `https` in the above example.
     scheme: ~str,
-    /// A URL subcomponent for user authentication.  `username` in the above example.
     user: Option<UserInfo>,
-    /// A domain name or IP address.  For example, `example.com`.
     host: ~str,
-    /// A TCP port number, for example `8080`.
     port: Option<~str>,
-    /// The path component of a URL, for example `/foo/bar`.
     path: ~str,
-    /// The query component of a URL.  `~[(~"baz", ~"qux")]` represents the
-    /// fragment `baz=qux` in the above example.
     query: Query,
-    /// The fragment component, such as `quz`.  Doesn't include the leading `#` character.
     fragment: Option<~str>
 }
 
-/// An optional subcomponent of a URI authority component.
 #[deriving(Clone, Eq)]
 pub struct UserInfo {
-    /// The user name.
     user: ~str,
-    /// Password or other scheme-specific authentication information.
     pass: Option<~str>
 }
 
-/// Represents the query component of a URI.
 pub type Query = ~[(~str, ~str)];
 
 impl Url {

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

@@ -119,25 +119,18 @@ impl Archive {
     }
 
     fn find_library(&self, name: &str) -> Path {
-        let (osprefix, osext) = match self.sess.targ_cfg.os {
+        let (prefix, ext) = match self.sess.targ_cfg.os {
             abi::OsWin32 => ("", "lib"), _ => ("lib", "a"),
         };
-        // On windows, static libraries sometimes show up as libfoo.a and other
-        // times show up as foo.lib
-        let oslibname = format!("{}{}.{}", osprefix, name, osext);
-        let unixlibname = format!("lib{}.a", name);
+        let libname = format!("{}{}.{}", prefix, name, ext);
 
         let mut rustpath = filesearch::rust_path();
         rustpath.push(self.sess.filesearch.get_target_lib_path());
         let path = self.sess.opts.addl_lib_search_paths.iter();
         for path in path.chain(rustpath.iter()) {
             debug!("looking for {} inside {}", name, path.display());
-            let test = path.join(oslibname.as_slice());
+            let test = path.join(libname.clone());
             if test.exists() { return test }
-            if oslibname != unixlibname {
-                let test = path.join(unixlibname.as_slice());
-                if test.exists() { return test }
-            }
         }
         self.sess.fatal(format!("could not find native static library `{}`, \
                                  perhaps an -L flag is missing?", name));

branches/try/src/librustc/middle/typeck/check/_match.rs

@@ -294,24 +294,17 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
                                etc: bool) {
     let tcx = pcx.fcx.ccx.tcx;
 
-    // Index the class fields. The second argument in the tuple is whether the
-    // field has been bound yet or not.
+    // Index the class fields.
     let mut field_map = HashMap::new();
     for (i, class_field) in class_fields.iter().enumerate() {
-        field_map.insert(class_field.name, (i, false));
+        field_map.insert(class_field.name, i);
     }
 
     // Typecheck each field.
     let mut found_fields = HashSet::new();
     for field in fields.iter() {
-        match field_map.find_mut(&field.ident.name) {
-            Some(&(_, true)) => {
-                tcx.sess.span_err(span,
-                    format!("field `{}` bound twice in pattern",
-                            tcx.sess.str_of(field.ident)));
-            }
-            Some(&(index, ref mut used)) => {
-                *used = true;
+        match field_map.find(&field.ident.name) {
+            Some(&index) => {
                 let class_field = class_fields[index];
                 let field_type = ty::lookup_field_type(tcx,
                                                        class_id,

branches/try/src/librustuv/timer.rs

@@ -77,8 +77,8 @@ impl RtioTimer for TimerWatcher {
         let _missile = match util::replace(&mut self.action, None) {
             None => missile, // no need to do a homing dance
             Some(action) => {
-                drop(missile);      // un-home ourself
-                drop(action);       // destroy the previous action
+                util::ignore(missile);      // un-home ourself
+                util::ignore(action);       // destroy the previous action
                 self.fire_homing_missile()  // re-home ourself
             }
         };

branches/try/src/librustuv/uvio.rs

@@ -26,6 +26,7 @@ use std::libc::{O_CREAT, O_APPEND, O_TRUNC, O_RDWR, O_RDONLY, O_WRONLY,
 use std::io::{FileMode, FileAccess, Open, Append, Truncate, Read, Write,
                   ReadWrite, FileStat};
 use std::io::signal::Signum;
+use std::util;
 use ai = std::io::net::addrinfo;
 
 #[cfg(test)] use std::unstable::run_in_bare_thread;
@@ -103,7 +104,7 @@ impl HomingMissile {
 
 impl Drop for HomingMissile {
     fn drop(&mut self) {
-        let _f = ForbidUnwind::new("leaving home");
+        let f = ForbidUnwind::new("leaving home");
 
         // It would truly be a sad day if we had moved off the home I/O
         // scheduler while we were doing I/O.
@@ -119,6 +120,8 @@ impl Drop for HomingMissile {
                 });
             })
         }
+
+        util::ignore(f);
     }
 }
 

branches/try/src/libstd/io/fs.rs

@@ -1179,7 +1179,7 @@ mod test {
         file.write(bytes!("foo"));
         file.fsync();
         file.datasync();
-        drop(file);
+        util::ignore(file);
     })
 
     test!(fn truncate_works() {
@@ -1210,7 +1210,7 @@ mod test {
         assert_eq!(stat(&path).size, 9);
         assert_eq!(File::open(&path).read_to_end(),
                    (bytes!("fo", 0, 0, 0, 0, "wut")).to_owned());
-        drop(file);
+        util::ignore(file);
     })
 
     test!(fn open_flavors() {

branches/try/src/libstd/prelude.rs

@@ -86,7 +86,3 @@ pub use vec::{Vector, VectorVector, CopyableVector, ImmutableVector};
 // Reexported runtime types
 pub use comm::{stream, Port, Chan, GenericChan, GenericSmartChan, GenericPort, Peekable};
 pub use task::spawn;
-
-/// Disposes of a value.
-#[inline]
-pub fn drop<T>(_x: T) { }

branches/try/src/libstd/rt/sched.rs

@@ -1173,6 +1173,7 @@ mod test {
         use rt::sleeper_list::SleeperList;
         use rt::stack::StackPool;
         use rt::sched::{Shutdown, TaskFromFriend};
+        use util;
 
         do run_in_bare_thread {
             stress_factor().times(|| {
@@ -1204,7 +1205,7 @@ mod test {
                 handle.send(TaskFromFriend(task));
 
                 handle.send(Shutdown);
-                drop(handle);
+                util::ignore(handle);
 
                 thread.join();
             })

branches/try/src/libstd/unstable/sync.rs

@@ -467,6 +467,7 @@ mod tests {
     use prelude::*;
     use super::{Exclusive, UnsafeArc, atomically};
     use task;
+    use util;
     use mem::size_of;
 
     //#[unsafe_no_drop_flag] FIXME: #9758
@@ -570,7 +571,7 @@ mod tests {
         let x2 = x.clone();
         let left_x = x.try_unwrap();
         assert!(left_x.is_self());
-        drop(left_x);
+        util::ignore(left_x);
         assert!(x2.try_unwrap().expect_t("try_unwrap none") == ~~"hello");
     }
 
@@ -589,7 +590,7 @@ mod tests {
         task::deschedule(); // Try to make the unwrapper get blocked first.
         let left_x = x.try_unwrap();
         assert!(left_x.is_self());
-        drop(left_x);
+        util::ignore(left_x);
         p.recv();
     }
 
@@ -619,7 +620,7 @@ mod tests {
             assert!(x2.unwrap() == ~~"hello");
         }
         // Have to get rid of our reference before blocking.
-        drop(x);
+        util::ignore(x);
         res.recv();
     }
 

branches/try/src/libstd/util.rs

@@ -19,6 +19,10 @@ use unstable::intrinsics;
 #[inline]
 pub fn id<T>(x: T) -> T { x }
 
+/// Ignores a value.
+#[inline]
+pub fn ignore<T>(_x: T) { }
+
 /**
  * Swap the values at two mutable locations of the same type, without
  * deinitialising or copying either one.