---

yaml
---
r: 83945
b: refs/heads/dist-snap
c: 8c50ee3
h: refs/heads/master
i:
  83943: fd2475e
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: b6024e4ca27bda4846b1a7829f098caf4d140f71
+refs/heads/dist-snap: 8c50ee3916e049eb100f68a236bf99542f244b52
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -2869,24 +2869,19 @@ The kinds are:
   : Types of this kind can be safely sent between tasks.
     This kind includes scalars, owning pointers, owned closures, and
     structural types containing only other owned types. All `Send` types are `Static`.
-`Static`
-  : Types of this kind do not contain any borrowed pointers;
-    this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).
 `Copy`
   : This kind includes all types that can be copied. All types with
     sendable kind are copyable, as are managed boxes, managed closures,
     trait types, and structural types built out of these.
     Types with destructors (types that implement `Drop`) can not implement `Copy`.
 `Drop`
   : This is not strictly a kind, but its presence interacts with kinds: the `Drop`
-    trait provides a single method `finalize` that takes no parameters, and is run
+    trait provides a single method `drop` that takes no parameters, and is run
     when values of the type are dropped. Such a method is called a "destructor",
     and are always executed in "top-down" order: a value is completely destroyed
     before any of the values it owns run their destructors. Only `Send` types
     that do not implement `Copy` can implement `Drop`.
 
-> **Note:** The `finalize` method may be renamed in future versions of Rust.
-
 _Default_
   : Types with destructors, closure environments,
     and various other _non-first-class_ types,

branches/dist-snap/src/libextra/extra.rs

@@ -40,8 +40,10 @@ pub mod uv_ll;
 
 // General io and system-services modules
 
-#[path = "net/mod.rs"]
 pub mod net;
+pub mod net_ip;
+pub mod net_tcp;
+pub mod net_url;
 
 // libuv modules
 pub mod uv;

branches/dist-snap/src/libextra/net/mod.rs renamed to branches/dist-snap/src/libextra/net.rs

@@ -13,13 +13,13 @@ Top-level module for network-related functionality.
 
 Basically, including this module gives you:
 
-* `tcp`
-* `ip`
-* `url`
+* `net_tcp`
+* `net_ip`
+* `net_url`
 
 See each of those three modules for documentation on what they do.
 */
 
-pub mod tcp;
-pub mod ip;
-pub mod url;
+pub use tcp = net_tcp;
+pub use ip = net_ip;
+pub use url = net_url;

branches/dist-snap/src/libextra/net/ip.rs renamed to branches/dist-snap/src/libextra/net_ip.rs

@@ -22,20 +22,20 @@ use std::str;
 use iotask = uv::iotask::IoTask;
 use interact = uv::iotask::interact;
 
-use sockaddr_in = uv_ll::sockaddr_in;
-use sockaddr_in6 = uv_ll::sockaddr_in6;
-use addrinfo = uv_ll::addrinfo;
-use uv_getaddrinfo_t = uv_ll::uv_getaddrinfo_t;
-use uv_ip4_name = uv_ll::ip4_name;
-use uv_ip4_port = uv_ll::ip4_port;
-use uv_ip6_name = uv_ll::ip6_name;
-use uv_ip6_port = uv_ll::ip6_port;
-use uv_getaddrinfo = uv_ll::getaddrinfo;
-use uv_freeaddrinfo = uv_ll::freeaddrinfo;
-use create_uv_getaddrinfo_t = uv_ll::getaddrinfo_t;
-use set_data_for_req = uv_ll::set_data_for_req;
-use get_data_for_req = uv_ll::get_data_for_req;
-use ll = uv_ll;
+use sockaddr_in = super::uv_ll::sockaddr_in;
+use sockaddr_in6 = super::uv_ll::sockaddr_in6;
+use addrinfo = super::uv_ll::addrinfo;
+use uv_getaddrinfo_t = super::uv_ll::uv_getaddrinfo_t;
+use uv_ip4_name = super::uv_ll::ip4_name;
+use uv_ip4_port = super::uv_ll::ip4_port;
+use uv_ip6_name = super::uv_ll::ip6_name;
+use uv_ip6_port = super::uv_ll::ip6_port;
+use uv_getaddrinfo = super::uv_ll::getaddrinfo;
+use uv_freeaddrinfo = super::uv_ll::freeaddrinfo;
+use create_uv_getaddrinfo_t = super::uv_ll::getaddrinfo_t;
+use set_data_for_req = super::uv_ll::set_data_for_req;
+use get_data_for_req = super::uv_ll::get_data_for_req;
+use ll = super::uv_ll;
 
 /// An IP address
 pub enum IpAddr {
@@ -363,9 +363,9 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t,
 #[cfg(test)]
 mod test {
 
-    use net::ip::*;
-    use net::ip::v4;
-    use net::ip::v6;
+    use net_ip::*;
+    use net_ip::v4;
+    use net_ip::v6;
     use uv;
 
     use std::result;

branches/dist-snap/src/libextra/net/tcp.rs renamed to branches/dist-snap/src/libextra/net_tcp.rs

@@ -16,7 +16,7 @@
 
 use future;
 use future_spawn = future::spawn;
-use ip = net::ip;
+use ip = net_ip;
 use uv;
 use uv::iotask;
 use uv::iotask::IoTask;

branches/dist-snap/src/libextra/net/url.rs renamed to branches/dist-snap/src/libextra/net_url.rs

@@ -800,7 +800,7 @@ fn test_get_path() {
 #[cfg(test)]
 mod tests {
 
-    use net::url::*;
+    use net_url::*;
 
     use std::hashmap::HashMap;
 

branches/dist-snap/src/libextra/treemap.rs

@@ -57,23 +57,25 @@ impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> {
 }
 
 // Lexicographical comparison
-fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>,
+fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
                                  b: &TreeMap<K, V>) -> bool {
     let mut x = a.iter();
     let mut y = b.iter();
 
     let (a_len, b_len) = (a.len(), b.len());
     for uint::min(a_len, b_len).times {
-        let (key_a,_) = x.next().unwrap();
-        let (key_b,_) = y.next().unwrap();
+        let (key_a, value_a) = x.next().unwrap();
+        let (key_b, value_b) = y.next().unwrap();
         if *key_a < *key_b { return true; }
         if *key_a > *key_b { return false; }
-    };
+        if *value_a < *value_b { return true; }
+        if *value_a > *value_b { return false; }
+    }
 
     a_len < b_len
 }
 
-impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
+impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> {
     #[inline]
     fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
     #[inline]
@@ -935,7 +937,7 @@ mod test_treemap {
         assert!(b.insert(0, 5));
         assert!(a < b);
         assert!(a.insert(0, 7));
-        assert!(!(a < b) && !(b < a));
+        assert!(!(a < b) && b < a);
         assert!(b.insert(-2, 0));
         assert!(b < a);
         assert!(a.insert(-5, 2));

branches/dist-snap/src/libstd/bool.rs

@@ -122,6 +122,7 @@ pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 * ~~~ {.rust}
 * rusti> std::bool::implies(true, true)
 * true
+* ~~~
 *
 * ~~~ {.rust}
 * rusti> std::bool::implies(true, false)

branches/dist-snap/src/libstd/kinds.rs

@@ -18,7 +18,7 @@ intrinsic properties of the type. These classifications, often called
 They cannot be implemented by user code, but are instead implemented
 by the compiler automatically for the types to which they apply.
 
-The 4 kinds are
+The 3 kinds are
 
 * Copy - types that may be copied without allocation. This includes
   scalar types and managed pointers, and exludes owned pointers. It