---

yaml
---
r: 92917
b: refs/heads/auto
c: ff578b7
h: refs/heads/master
i:
  92915: a7428cc
v: v3

Author: bors

[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: 65baedfa1f7129073d69c0c4ab0e86cd0eb54b14
+refs/heads/auto: ff578b7c83efd8d8335dad86f83da346753c8f34
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/RELEASES.txt

@@ -1,10 +1,156 @@
-Version 0.9 (XXX 2013)
+Version 0.9 (January 2014)
 --------------------------
 
-   * ~XXX changes, numerous bugfixes
+   * ~1600 changes, numerous bugfixes
+
+   * Language
+      * The `float` type has been removed. Use `f32` or `f64` instead.
+      * A new facility for enabling experimental features (feature gating) has
+        been added, using the crate-level `#[feature(foo)]` attribute.
+      * Managed boxes (@) are now behind a feature gate
+        (`#[feature(managed_boxes)]`) in preperation for future removal. Use the
+        standard library's `Gc` or `Rc` types instead.
+      * `@mut` has been removed. Use `std::cell::{Cell, RefCell}` instead.
+      * Jumping back to the top of a loop is now done with `continue` instead of
+        `loop`.
+      * Strings can no longer be mutated through index assignment.
+      * Raw strings can be created via the basic `r"foo"` syntax or with matched
+        hash delimiters, as in `r###"foo"###`.
+      * `~fn` is now written `proc (args) -> retval { ... }` and may only be
+        called once.
+      * The `&fn` type is now written `|args| -> ret` to match the literal form.
+      * `@fn`s have been removed.
+      * `do` only works with procs in order to make it obvious what the cost
+        of `do` is.
+      * The `#[link(...)]` attribute has been replaced with
+        `#[crate_id = "name#vers"]`.
+      * Empty `impl`s must be terminated with empty braces and may not be
+        terminated with a semicolon.
+      * Keywords are no longer allowed as lifetime names; the `self` lifetime
+        no longer has any special meaning.
+      * The old `fmt!` string formatting macro has been removed.
+      * `printf!` and `printfln!` (old-style formatting) removed in favor of
+        `print!` and `println!`.
+      * `mut` works in patterns now, as in `let (mut x, y) = (1, 2);`.
+      * New reserved keywords: `alignof`, `offsetof`, `sizeof`.
+      * Macros can have attributes.
+      * Macros can expand to items with attributes.
+      * Macros can expand to multiple items.
+      * The `asm!` macro is feature-gated (`#[feature(asm)]`).
+      * Comments may be nested.
+      * Values automatically coerce to trait objects they implement, without
+        an explicit `as`.
+      * Enum discriminants are no longer an entire word but as small as needed to
+        contain all the variants. The `repr` attribute can be used to override
+        the discriminant size, as in `#[repr(int)]` for integer-sized, and
+        `#[repr(C)]` to match C enums.
+      * Non-string literals are not allowed in attributes (they never worked).
+      * The FFI now supports variadic functions.
+      * Octal numeric literals, as in `0o7777`.
+      * The `concat!` syntax extension performs compile-time string concatenation.
+      * The `#[fixed_stack_segment]` and `#[rust_stack]` attributes have been
+        removed as Rust no longer uses segmented stacks.
+      * Non-ascii identifiers are feature-gated (`#[feature(non_ascii_idents)]`).
+      * Ignoring all fields of an enum variant or tuple-struct is done with `..`,
+        not `*`; ignoring remaining fields of a struct is also done with `..`,
+        not `_`; ignoring a slice of a vector is done with `..`, not `.._`.
+      * `rustc` supports the "win64" calling convention via `extern "win64"`.
+      * `rustc` supports the "system" calling convention, which defaults to the
+        preferred convention for the target platform, "stdcall" on 32-bit Windows,
+        "C" elsewhere.
+      * The `type_overflow` lint (default: warn) checks literals for overflow.
+      * The `unsafe_block` lint (default: allow) checks for usage of `unsafe`.
+      * The `attribute_usage` lint (default: warn) warns about unknown
+        attributes.
+      * The `unknown_features` lint (default: warn) warns about unknown
+        feature gates.
+      * The `dead_code` lint (default: warn) checks for dead code.
+      * Rust libraries can be linked statically to one another
+      * `#[link_args]` is behind the `link_args` feature gate.
+      * Native libraries are now linked with `#[link(name = "foo")]`
+      * Native libraries can be statically linked to a rust crate
+        (`#[link(name = "foo", kind = "static")]`).
+      * Native OS X frameworks are now officially supported
+        (`#[link(name = "foo", kind = "framework")]`).
+      * The `#[thread_local]` attribute creates thread-local (not task-local)
+        variables. Currently behind the `thread_local` feature gate.
+      * The `return` keyword may be used in closures.
+      * Types that can be copied via a memcpy implement the `Pod` kind.
+
+   * Libraries
+      * std: The `option` and `result` API's have been overhauled to make them
+        simpler, more consistent, and more composable.
+      * std: The entire `std::io` module has been replaced with one that is
+        more comprehensive and that properly interfaces with the underlying
+        scheduler. File, TCP, UDP, Unix sockets, pipes, and timers are all
+        implemented.
+      * std: `io::util` contains a number of useful implementations of
+        `Reader` and `Writer`, including `NullReader`, `NullWriter`,
+        `ZeroReader`, `TeeReader`.
+      * std: The reference counted pointer type `extra::rc` moved into std.
+      * std: The `Gc` type in the `gc` module will replace `@` (it is currently
+        just a wrapper around it).
+      * std: `fmt::Default` can be implemented for any type to provide default
+        formatting to the `format!` macro, as in `format!("{}", myfoo)`.
+      * std: The `rand` API continues to be tweaked.
+      * std: Functions dealing with type size and alignment have moved from the
+        `sys` module to the `mem` module.
+      * std: The `path` module was written and API changed.
+      * std: `str::from_utf8` has been changed to cast instead of allocate.
+      * std: `starts_with` and `ends_with` methods added to vectors via the
+        `ImmutableEqVector` trait, which is in the prelude.
+      * std: Vectors can be indexed with the `get_opt` method, which returns `None`
+        if the index is out of bounds.
+      * std: Task failure no longer propagates between tasks, as the model was
+        complex, expensive, and incompatible with thread-based tasks.
+      * std: The `Any` type can be used for dynamic typing.
+      * std: `~Any` can be passed to the `fail!` macro and retrieved via
+        `task::try`.
+      * std: Methods that produce iterators generally do not have an `_iter`
+        suffix now.
+      * std: `cell::Cell` and `cell::RefCell` can be used to introduce mutability
+        roots (mutable fields, etc.). Use instead of e.g. `@mut`.
+      * std: `util::ignore` renamed to `prelude::drop`.
+      * std: Slices have `sort` and `sort_by` methods via the `MutableVector`
+        trait.
+      * std: `vec::raw` has seen a lot of cleanup and API changes.
+      * std: The standard library no longer includes any C++ code, and very
+        minimal C, eliminating the dependency on libstdc++.
+      * std: Runtime scheduling and I/O functionality has been factored out into
+        extensible interfaces and is now implemented by two different crates:
+        libnative, for native threading and I/O; and libgreen, for green threading
+        and I/O. This paves the way for using the standard library in more limited
+        embeded environments.
+      * std: The `comm` module has been rewritten to be much faster, have a
+        simpler, more consistent API, and to work for both native and green
+        threading.
+      * std: All libuv dependencies have been moved into the rustuv crate.
+      * native: New implementations of runtime scheduling on top of OS threads.
+      * native: New native implementations of TCP, UDP, file I/O, process spawning,
+        and other I/O.
+      * green: The green thread scheduler and message passing types are almost
+        entirely lock-free.
+      * extra: The `flatpipes` module had bitrotted and was removed.
+      * extra: All crypto functions have been removed and Rust now has a policy of
+        not reimplementing crypto in the standard library. In the future crypto
+        will be provided by external crates with bindings to established libraries.
+      * extra: `c_vec` has been modernized.
+      * extra: The `sort` module has been removed. Use the `sort` method on
+        mutable slices.
 
    * Tooling
-      * The `rust` and `rusti` commands have been removed, due to lack of maintenance.
+      * The `rust` and `rusti` commands have been removed, due to lack of
+        maintenance.
+      * `rustdoc` was completely rewritten.
+      * `rustdoc` can test code examples in documentation.
+      * `rustpkg` can test packages with the argument, 'test'.
+      * `rustpkg` supports arbitrary dependencies, including C libraries.
+      * `rustc`'s support for generating debug info is improved again.
+      * `rustc` has better error reporting for unbalanced delimiters.
+      * `rustc`'s JIT support was removed due to bitrot.
+      * Executables and static libraries can be built with LTO (-Z lto)
+      * `rustc` adds a `--dep-info` flag for communicating dependencies to
+        build tools.
 
 Version 0.8 (September 2013)
 --------------------------

branches/auto/src/libextra/ebml.rs

@@ -122,11 +122,9 @@ pub mod reader {
         fail!("vint too big");
     }
 
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "x86_64")]
     pub fn vuint_at(data: &[u8], start: uint) -> Res {
         use std::ptr::offset;
-        use std::unstable::intrinsics::bswap32;
+        use std::unstable::intrinsics::from_be32;
 
         if data.len() - start < 4 {
             return vuint_at_slow(data, start);
@@ -136,7 +134,7 @@ pub mod reader {
             let (ptr, _): (*u8, uint) = transmute(data);
             let ptr = offset(ptr, start as int);
             let ptr: *i32 = transmute(ptr);
-            let val = bswap32(*ptr);
+            let val = from_be32(*ptr);
             let val: u32 = transmute(val);
             if (val & 0x80000000) != 0 {
                 Res {
@@ -162,11 +160,6 @@ pub mod reader {
         }
     }
 
-    #[cfg(not(target_arch = "x86"), not(target_arch = "x86_64"))]
-    pub fn vuint_at(data: &[u8], start: uint) -> Res {
-        vuint_at_slow(data, start)
-    }
-
     pub fn Doc<'a>(data: &'a [u8]) -> Doc<'a> {
         Doc { data: data, start: 0u, end: data.len() }
     }

branches/auto/src/libnative/io/net.rs

@@ -26,15 +26,11 @@ use super::file::keep_going;
 #[cfg(windows)] pub type sock_t = libc::SOCKET;
 #[cfg(unix)]    pub type sock_t = super::file::fd_t;
 
-#[cfg(target_endian = "big")] pub fn htons(x: u16) -> u16 { x }
-#[cfg(target_endian = "big")] pub fn ntohs(x: u16) -> u16 { x }
-#[cfg(target_endian = "little")]
 pub fn htons(u: u16) -> u16 {
-    unsafe { intrinsics::bswap16(u as i16) as u16 }
+    intrinsics::to_be16(u as i16) as u16
 }
-#[cfg(target_endian = "little")]
 pub fn ntohs(u: u16) -> u16 {
-    unsafe { intrinsics::bswap16(u as i16) as u16 }
+    intrinsics::from_be16(u as i16) as u16
 }
 
 enum InAddr {

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

@@ -62,6 +62,13 @@ impl MarkSymbolVisitor {
         }
     }
 
+    fn check_def_id(&mut self, def_id: ast::DefId) {
+        if should_explore(self.tcx, def_id) {
+            self.worklist.push(def_id.node);
+        }
+        self.live_symbols.insert(def_id.node);
+    }
+
     fn lookup_and_handle_definition(&mut self, id: &ast::NodeId) {
         let def_map = self.tcx.def_map.borrow();
         let def = match def_map.get().find(id) {
@@ -74,13 +81,44 @@ impl MarkSymbolVisitor {
             _ => Some(def_id_of_def(def)),
         };
         match def_id {
-            Some(def_id) => {
-                if should_explore(self.tcx, def_id) {
-                    self.worklist.push(def_id.node);
+            Some(def_id) => self.check_def_id(def_id),
+            None => (),
+        }
+    }
+
+    fn lookup_and_handle_method(&mut self, id: &ast::NodeId,
+                                span: codemap::Span) {
+        let method_map = self.method_map.borrow();
+        match method_map.get().find(id) {
+            Some(&typeck::method_map_entry { origin, .. }) => {
+                match origin {
+                    typeck::method_static(def_id) => {
+                        match ty::provided_source(self.tcx, def_id) {
+                            Some(p_did) => self.check_def_id(p_did),
+                            None => self.check_def_id(def_id)
+                        }
+                    }
+                    typeck::method_param(typeck::method_param {
+                        trait_id: trait_id,
+                        method_num: index,
+                        ..
+                    })
+                    | typeck::method_object(typeck::method_object {
+                        trait_id: trait_id,
+                        method_num: index,
+                        ..
+                    }) => {
+                        let def_id = ty::trait_method(self.tcx,
+                                                      trait_id, index).def_id;
+                        self.check_def_id(def_id);
+                    }
                 }
-                self.live_symbols.insert(def_id.node);
             }
-            None => (),
+            None => {
+                self.tcx.sess.span_bug(span,
+                                       "method call expression not \
+                                        in method map?!")
+            }
         }
     }
 
@@ -135,24 +173,7 @@ impl Visitor<()> for MarkSymbolVisitor {
     fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
         match expr.node {
             ast::ExprMethodCall(..) => {
-                let method_map = self.method_map.borrow();
-                match method_map.get().find(&expr.id) {
-                    Some(&typeck::method_map_entry {
-                        origin: typeck::method_static(def_id),
-                        ..
-                    }) => {
-                        if should_explore(self.tcx, def_id) {
-                            self.worklist.push(def_id.node);
-                        }
-                        self.live_symbols.insert(def_id.node);
-                    }
-                    Some(_) => (),
-                    None => {
-                        self.tcx.sess.span_bug(expr.span,
-                                               "method call expression not \
-                                                in method map?!")
-                    }
-                }
+                self.lookup_and_handle_method(&expr.id, expr.span);
             }
             _ => ()
         }

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

@@ -167,6 +167,23 @@ struct EmbargoVisitor<'a> {
     reexports: HashSet<ast::NodeId>,
 }
 
+impl<'a> EmbargoVisitor<'a> {
+    // There are checks inside of privacy which depend on knowing whether a
+    // trait should be exported or not. The two current consumers of this are:
+    //
+    //  1. Should default methods of a trait be exported?
+    //  2. Should the methods of an implementation of a trait be exported?
+    //
+    // The answer to both of these questions partly rely on whether the trait
+    // itself is exported or not. If the trait is somehow exported, then the
+    // answers to both questions must be yes. Right now this question involves
+    // more analysis than is currently done in rustc, so we conservatively
+    // answer "yes" so that all traits need to be exported.
+    fn exported_trait(&self, _id: ast::NodeId) -> bool {
+        true
+    }
+}
+
 impl<'a> Visitor<()> for EmbargoVisitor<'a> {
     fn visit_item(&mut self, item: @ast::item, _: ()) {
         let orig_all_pub = self.prev_exported;
@@ -175,6 +192,12 @@ impl<'a> Visitor<()> for EmbargoVisitor<'a> {
             // cannot have visibility qualifiers on them anyway
             ast::item_impl(..) | ast::item_foreign_mod(..) => {}
 
+            // Traits are a little special in that even if they themselves are
+            // not public they may still be exported.
+            ast::item_trait(..) => {
+                self.prev_exported = self.exported_trait(item.id);
+            }
+
             // Private by default, hence we only retain the "public chain" if
             // `pub` is explicitly listed.
             _ => {

branches/auto/src/librustc/middle/trans/base.rs

@@ -20,7 +20,7 @@
 //   * There's no way to find out the ty::t type of a ValueRef.  Doing so
 //     would be "trying to get the eggs out of an omelette" (credit:
 //     pcwalton).  You can, instead, find out its TypeRef by calling val_ty,
-//     but many TypeRefs correspond to one ty::t; for instance, tup(int, int,
+//     but one TypeRef corresponds to many `ty::t`s; for instance, tup(int, int,
 //     int) and rec(x=int, y=int, z=int) will have the same TypeRef.
 
 

branches/auto/src/libstd/io/mod.rs

@@ -53,6 +53,8 @@ Some examples of obvious things you might want to do
     # let _g = ::std::io::ignore_io_error();
     let mut file = File::create(&Path::new("message.txt"));
     file.write(bytes!("hello, file!\n"));
+    # drop(file);
+    # ::std::io::fs::unlink(&Path::new("message.txt"));
     ```
 
 * Iterate over the lines of a file

branches/auto/src/libstd/local_data.rs

@@ -62,6 +62,7 @@ pub type Key<T> = &'static KeyValue<T>;
 #[allow(missing_doc)]
 pub enum KeyValue<T> { Key }
 
+#[allow(missing_doc)]
 trait LocalData {}
 impl<T: 'static> LocalData for T {}
 

branches/auto/src/libstd/unstable/intrinsics.rs

@@ -500,6 +500,19 @@ extern "rust-intrinsic" {
 #[cfg(target_endian = "little")] pub fn to_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
 #[cfg(target_endian = "big")]    pub fn to_be64(x: i64) -> i64 { x }
 
+#[cfg(target_endian = "little")] pub fn from_le16(x: i16) -> i16 { x }
+#[cfg(target_endian = "big")]    pub fn from_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] pub fn from_le32(x: i32) -> i32 { x }
+#[cfg(target_endian = "big")]    pub fn from_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] pub fn from_le64(x: i64) -> i64 { x }
+#[cfg(target_endian = "big")]    pub fn from_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
+
+#[cfg(target_endian = "little")] pub fn from_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")]    pub fn from_be16(x: i16) -> i16 { x }
+#[cfg(target_endian = "little")] pub fn from_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")]    pub fn from_be32(x: i32) -> i32 { x }
+#[cfg(target_endian = "little")] pub fn from_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")]    pub fn from_be64(x: i64) -> i64 { x }
 
 /// `TypeId` represents a globally unique identifier for a type
 #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and