---

yaml
---
r: 94063
b: refs/heads/try
c: 1191ae8
h: refs/heads/master
i:
  94061: d99e077
  94059: a3c946f
  94055: df9d00c
  94047: f0903aa
v: v3

Author: bors

[refs]

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

branches/try/src/libextra/url.rs

@@ -19,23 +19,51 @@ 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,18 +119,25 @@ impl Archive {
     }
 
     fn find_library(&self, name: &str) -> Path {
-        let (prefix, ext) = match self.sess.targ_cfg.os {
+        let (osprefix, osext) = match self.sess.targ_cfg.os {
             abi::OsWin32 => ("", "lib"), _ => ("lib", "a"),
         };
-        let libname = format!("{}{}.{}", prefix, name, ext);
+        // 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 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(libname.clone());
+            let test = path.join(oslibname.as_slice());
             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,17 +294,24 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
                                etc: bool) {
     let tcx = pcx.fcx.ccx.tcx;
 
-    // Index the class fields.
+    // Index the class fields. The second argument in the tuple is whether the
+    // field has been bound yet or not.
     let mut field_map = HashMap::new();
     for (i, class_field) in class_fields.iter().enumerate() {
-        field_map.insert(class_field.name, i);
+        field_map.insert(class_field.name, (i, false));
     }
 
     // Typecheck each field.
     let mut found_fields = HashSet::new();
     for field in fields.iter() {
-        match field_map.find(&field.ident.name) {
-            Some(&index) => {
+        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;
                 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) => {
-                util::ignore(missile);      // un-home ourself
-                util::ignore(action);       // destroy the previous action
+                drop(missile);      // un-home ourself
+                drop(action);       // destroy the previous action
                 self.fire_homing_missile()  // re-home ourself
             }
         };

branches/try/src/librustuv/uvio.rs

@@ -26,7 +26,6 @@ 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;
@@ -104,7 +103,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.
@@ -120,8 +119,6 @@ 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();
-        util::ignore(file);
+        drop(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());
-        util::ignore(file);
+        drop(file);
     })
 
     test!(fn open_flavors() {

branches/try/src/libstd/prelude.rs

@@ -86,3 +86,7 @@ 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,7 +1173,6 @@ 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(|| {
@@ -1205,7 +1204,7 @@ mod test {
                 handle.send(TaskFromFriend(task));
 
                 handle.send(Shutdown);
-                util::ignore(handle);
+                drop(handle);
 
                 thread.join();
             })

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

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

branches/try/src/libstd/util.rs

@@ -19,10 +19,6 @@ 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.

branches/try/src/test/compile-fail/issue-9725.rs

@@ -0,0 +1,15 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A { foo: int }
+
+fn main() {
+    let A { foo, foo } = A { foo: 3 }; //~ ERROR: field `foo` bound twice
+}

branches/try/src/test/compile-fail/lint-unused-imports.rs

@@ -63,7 +63,7 @@ mod bar {
 fn main() {
     cal(foo::Point{x:3, y:9});
     let a = 3;
-    ignore(a);
+    id(a);
     test::C.b();
     let _a = from_elem(0, 0);
 }

branches/try/src/test/compile-fail/once-cant-call-twice-on-heap.rs

@@ -14,7 +14,6 @@
 #[feature(once_fns)];
 extern mod extra;
 use extra::arc;
-use std::util;
 
 fn foo(blk: proc()) {
     blk();
@@ -25,6 +24,6 @@ fn main() {
     let x = arc::Arc::new(true);
     do foo {
         assert!(*x.get());
-        util::ignore(x);
+        drop(x);
     }
 }

branches/try/src/test/compile-fail/once-cant-call-twice-on-stack.rs

@@ -14,7 +14,6 @@
 #[feature(once_fns)];
 extern mod extra;
 use extra::arc;
-use std::util;
 
 fn foo(blk: once ||) {
     blk();
@@ -25,6 +24,6 @@ fn main() {
     let x = arc::Arc::new(true);
     foo(|| {
         assert!(*x.get());
-        util::ignore(x);
+        drop(x);
     })
 }

branches/try/src/test/compile-fail/once-cant-move-out-of-non-once-on-stack.rs

@@ -13,7 +13,6 @@
 
 extern mod extra;
 use extra::arc;
-use std::util;
 
 fn foo(blk: ||) {
     blk();
@@ -24,6 +23,6 @@ fn main() {
     let x = arc::Arc::new(true);
     foo(|| {
         assert!(*x.get());
-        util::ignore(x); //~ ERROR cannot move out of captured outer variable
+        drop(x); //~ ERROR cannot move out of captured outer variable
     })
 }

branches/try/src/test/run-pass/once-move-out-on-heap.rs

@@ -15,7 +15,6 @@
 #[feature(once_fns)];
 extern mod extra;
 use extra::arc;
-use std::util;
 
 fn foo(blk: proc()) {
     blk();
@@ -25,6 +24,6 @@ fn main() {
     let x = arc::Arc::new(true);
     do foo {
         assert!(*x.get());
-        util::ignore(x);
+        drop(x);
     }
 }

branches/try/src/test/run-pass/once-move-out-on-stack.rs

@@ -15,7 +15,6 @@
 #[feature(once_fns)];
 extern mod extra;
 use extra::arc;
-use std::util;
 
 fn foo(blk: once ||) {
     blk();
@@ -25,6 +24,6 @@ fn main() {
     let x = arc::Arc::new(true);
     foo(|| {
         assert!(*x.get());
-        util::ignore(x);
+        drop(x);
     })
 }