---

yaml
---
r: 179708
b: refs/heads/auto
c: 34afe5e
h: refs/heads/master
v: v3

Author: alkor

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 0568422a27ce4dd9a7f2b1c71710700be54a1da4
+refs/heads/auto: 34afe5e193182a0029abe1ae8258f79f4cd56cd9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -653,7 +653,9 @@ probe CFG_GRUN             grun
 probe CFG_FLEX             flex
 probe CFG_BISON            bison
 probe CFG_PANDOC           pandoc
+probe CFG_PDFLATEX         pdflatex
 probe CFG_XELATEX          xelatex
+probe CFG_LUALATEX         lualatex
 probe CFG_GDB              gdb
 probe CFG_LLDB             lldb
 

branches/auto/mk/docs.mk

@@ -85,16 +85,27 @@ else
 HTML_DEPS :=
 endif
 
-# Check for xelatex
-
-ifeq ($(CFG_XELATEX),)
+# Check for the various external utilities for the EPUB/PDF docs:
+
+ifeq ($(CFG_LUALATEX),)
+  $(info cfg: no lualatex found, deferring to xelatex)
+  ifeq ($(CFG_XELATEX),)
+    $(info cfg: no xelatex found, deferring to pdflatex)
+    ifeq ($(CFG_PDFLATEX),)
+      $(info cfg: no pdflatex found, disabling LaTeX docs)
+      NO_PDF_DOCS = 1
+	else
+      CFG_LATEX := $(CFG_PDFLATEX)
+    endif
+  else
     CFG_LATEX := $(CFG_XELATEX)
     XELATEX = 1
-  else
-    $(info cfg: no xelatex found, disabling LaTeX docs)
-    NO_PDF_DOCS = 1
+  endif
+else
+  CFG_LATEX := $(CFG_LUALATEX)
 endif
 
+
 ifeq ($(CFG_PANDOC),)
 $(info cfg: no pandoc found, omitting PDF and EPUB docs)
 ONLY_HTML_DOCS = 1

branches/auto/src/doc/grammar.md

@@ -157,7 +157,7 @@ token : simple_token | ident | literal | symbol | whitespace token ;
 
 |          |          |          |          |        |
 |----------|----------|----------|----------|--------|
-| abstract | alignof  | as       | become   | box    |
+| abstract | alignof  | as       | be       | box    |
 | break    | const    | continue | crate    | do     |
 | else     | enum     | extern   | false    | final  |
 | fn       | for      | if       | impl     | in     |

branches/auto/src/doc/index.md

@@ -59,7 +59,8 @@ tools we have are really nice.
 [Cargo](http://crates.io) is Rust's package manager, and its website contains
 lots of good documentation.
 
-[`rustdoc`](book/documentation.html) is used to generate documentation for Rust code.
+[The `rustdoc` manual](rustdoc.html) contains information about Rust's
+documentation tool.
 
 # FAQs
 

branches/auto/src/doc/reference.md

@@ -189,7 +189,7 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 |          |          |          |          |         |
 |----------|----------|----------|----------|---------|
-| abstract | alignof  | as       | become   | box     |
+| abstract | alignof  | as       | be       | box     |
 | break    | const    | continue | crate    | do      |
 | else     | enum     | extern   | false    | final   |
 | fn       | for      | if       | impl     | in      |
@@ -381,13 +381,11 @@ character (`\`), or a single _escape_. It is equivalent to a `u8` unsigned
 
 ##### Byte string literals
 
-A non-raw _byte string literal_ is a sequence of ASCII characters and _escapes_,
-preceded by the characters `U+0062` (`b`) and `U+0022` (double-quote), and
-followed by the character `U+0022`. If the character `U+0022` is present within
-the literal, it must be _escaped_ by a preceding `U+005C` (`\`) character.
-Alternatively, a byte string literal can be a _raw byte string literal_, defined
-below. A byte string literal is equivalent to a `&'static [u8]` borrowed array
-of unsigned 8-bit integers.
+A _byte string literal_ is a sequence of ASCII characters and _escapes_
+enclosed within two `U+0022` (double-quote) characters, with the exception of
+`U+0022` itself, which must be _escaped_ by a preceding `U+005C` character
+(`\`), or a _raw byte string literal_. It is equivalent to a `&'static [u8]`
+borrowed array of unsigned 8-bit integers.
 
 Some additional _escapes_ are available in either byte or non-raw byte string
 literals. An escape starts with a `U+005C` (`\`) and continues with one of the
@@ -2016,11 +2014,6 @@ type int8_t = i8;
 - `no_start` - disable linking to the `native` crate, which specifies the
   "start" language item.
 - `no_std` - disable linking to the `std` crate.
-- `plugin` — load a list of named crates as compiler plugins, e.g.
-             `#![plugin(foo, bar)]`. Optional arguments for each plugin,
-             i.e. `#![plugin(foo(... args ...))]`, are provided to the plugin's
-             registrar function.  The `plugin` feature gate is required to use
-             this attribute.
 
 ### Module-only attributes
 
@@ -2089,7 +2082,7 @@ On `struct`s:
   remove any padding between fields (note that this is very fragile and may
   break platforms which require aligned access).
 
-### Macro-related attributes
+### Macro- and plugin-related attributes
 
 - `macro_use` on a `mod` — macros defined in this module will be visible in the
   module's parent, after this module has been included.
@@ -2104,8 +2097,13 @@ On `struct`s:
 
 - `macro_export` - export a macro for cross-crate usage.
 
-- `no_link` on an `extern crate` — even if we load this crate for macros, don't
-  link it into the output.
+- `plugin` on an `extern crate` — load this crate as a [compiler
+  plugin][plugin].  The `plugin` feature gate is required.  Any arguments to
+  the attribute, e.g. `#[plugin=...]` or `#[plugin(...)]`, are provided to the
+  plugin.
+
+- `no_link` on an `extern crate` — even if we load this crate for macros or
+  compiler plugins, don't link it into the output.
 
 See the [macros section of the
 book](book/macros.html#scoping-and-macro-import/export) for more information on
@@ -2356,8 +2354,8 @@ Supported traits for `derive` are:
 * `FromPrimitive`, to create an instance from a numeric primitive.
 * `Hash`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
-* `Show`, to format a value using the `{}` formatter.
-* `Zero`, to create a zero instance of a numeric data type.
+* `Debug`, to format a value using the `{:?}` formatter.
+* `Copy`, for "Plain Old Data" types which can be copied by simply moving bits.
 
 ### Compiler Features
 

branches/auto/src/doc/trpl/compound-data-types.md

@@ -72,20 +72,6 @@ if x == y {
 
 This will print `no`, because some of the values aren't equal.
 
-Note that the order of the values is considered when checking for equality,
-so the following example will also print `no`.
-
-```rust
-let x = (1, 2, 3);
-let y = (2, 1, 3);
-
-if x == y {
-    println!("yes");
-} else {
-    println!("no");
-}
-```
-
 One other use of tuples is to return multiple values from a function:
 
 ```rust

branches/auto/src/doc/trpl/plugins.md

@@ -30,14 +30,14 @@ information.
 extend the compiler's behavior with new syntax extensions, lint checks, etc.
 
 A plugin is a dynamic library crate with a designated *registrar* function that
-registers extensions with `rustc`. Other crates can load these extensions using
-the crate attribute `#![plugin(...)]`.  See the
+registers extensions with `rustc`. Other crates can use these extensions by
+loading the plugin crate with `#[plugin] extern crate`. See the
 [`rustc::plugin`](../rustc/plugin/index.html) documentation for more about the
 mechanics of defining and loading a plugin.
 
-If present, arguments passed as `#![plugin(foo(... args ...))]` are not
-interpreted by rustc itself.  They are provided to the plugin through the
-`Registry`'s [`args` method](../rustc/plugin/registry/struct.Registry.html#method.args).
+Arguments passed as `#[plugin=...]` or `#[plugin(...)]` are not interpreted by
+rustc itself.  They are provided to the plugin through the `Registry`'s [`args`
+method](../rustc/plugin/registry/struct.Registry.html#method.args).
 
 # Syntax extensions
 
@@ -110,7 +110,8 @@ Then we can use `rn!()` like any other macro:
 
 ```ignore
 #![feature(plugin)]
-#![plugin(roman_numerals)]
+
+#[plugin] extern crate roman_numerals;
 
 fn main() {
     assert_eq!(rn!(MMXV), 2015);
@@ -218,7 +219,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
 Then code like
 
 ```ignore
-#![plugin(lint_plugin_test)]
+#[plugin] extern crate lint_plugin_test;
 
 fn lintme() { }
 ```

branches/auto/src/libcollections/lib.rs

@@ -30,7 +30,7 @@
 #![feature(unboxed_closures)]
 #![feature(unicode)]
 #![feature(unsafe_destructor, slicing_syntax)]
-#![cfg_attr(test, feature(rand, rustc_private, test))]
+#![cfg_attr(test, feature(test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 
 #![feature(no_std)]

branches/auto/src/libcollections/str.rs

@@ -80,7 +80,7 @@ pub use core::str::{Lines, LinesAny, MatchIndices, SplitStr, CharRange};
 pub use core::str::{Split, SplitTerminator};
 pub use core::str::{SplitN, RSplitN};
 pub use core::str::{from_utf8, CharEq, Chars, CharIndices, Bytes};
-pub use core::str::{from_utf8_unchecked, from_c_str, ParseBoolError};
+pub use core::str::{from_utf8_unchecked, from_c_str};
 pub use unicode::str::{Words, Graphemes, GraphemeIndices};
 
 /*

branches/auto/src/libcollections/vec.rs

@@ -690,8 +690,7 @@ impl<T> Vec<T> {
     /// Panics if the number of elements in the vector overflows a `usize`.
     ///
     /// # Examples
-    ///
-    /// ```
+    /// ```rust
     /// let mut vec = vec![1, 2, 3];
     /// let mut vec2 = vec![4, 5, 6];
     /// vec.append(&mut vec2);
@@ -1003,13 +1002,8 @@ impl<T> Vec<T> {
     ///
     /// Note that the capacity of `self` does not change.
     ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    ///
     /// # Examples
-    ///
-    /// ```
+    /// ```rust
     /// let mut vec = vec![1,2,3];
     /// let vec2 = vec.split_off(1);
     /// assert_eq!(vec, vec![1]);
@@ -1019,7 +1013,7 @@ impl<T> Vec<T> {
     #[unstable(feature = "collections",
                reason = "new API, waiting for dust to settle")]
     pub fn split_off(&mut self, at: usize) -> Self {
-        assert!(at <= self.len(), "`at` out of bounds");
+        assert!(at < self.len(), "`at` out of bounds");
 
         let other_len = self.len - at;
         let mut other = Vec::with_capacity(other_len);

branches/auto/src/libcore/any.rs

@@ -27,7 +27,7 @@
 //! # Examples
 //!
 //! Consider a situation where we want to log out a value passed to a function.
-//! We know the value we're working on implements Show, but we don't know its
+//! We know the value we're working on implements Debug, but we don't know its
 //! concrete type.  We want to give special treatment to certain types: in this
 //! case printing out the length of String values prior to their value.
 //! We don't know the concrete type of our value at compile time, so we need to

branches/auto/src/libcore/iter.rs

@@ -2646,7 +2646,13 @@ impl<A: Int> Iterator for RangeStepInclusive<A> {
 macro_rules! range_exact_iter_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
-        impl ExactSizeIterator for ::ops::Range<$t> { }
+        impl ExactSizeIterator for ::ops::Range<$t> {
+            #[inline]
+            fn len(&self) -> usize {
+                debug_assert!(self.end >= self.start);
+                (self.end - self.start) as usize
+            }
+        }
     )*)
 }
 
@@ -2667,12 +2673,9 @@ impl<A: Int> Iterator for ::ops::Range<A> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.start >= self.end {
-            (0, Some(0))
-        } else {
-            let length = (self.end - self.start).to_uint();
-            (length.unwrap_or(0), length)
-        }
+        debug_assert!(self.end >= self.start);
+        let hint = (self.end - self.start).to_uint();
+        (hint.unwrap_or(0), hint)
     }
 }
 

branches/auto/src/libcoretest/iter.rs

@@ -756,7 +756,6 @@ fn test_range() {
     // this test is only meaningful when sizeof uint < sizeof u64
     assert_eq!((uint::MAX - 1..uint::MAX).size_hint(), (1, Some(1)));
     assert_eq!((-10..-1).size_hint(), (9, Some(9)));
-    assert_eq!((-1..-10).size_hint(), (0, Some(0)));
 }
 
 #[test]

branches/auto/src/libgetopts/lib.rs

@@ -195,7 +195,7 @@ pub struct Matches {
 }
 
 /// The type returned when the command line does not conform to the
-/// expected format. Use the `Show` implementation to output detailed
+/// expected format. Use the `Debug` implementation to output detailed
 /// information.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Fail {
@@ -545,7 +545,7 @@ impl Fail {
     /// Convert a `Fail` enum into an error string.
     #[unstable(feature = "rustc_private")]
     #[deprecated(since = "1.0.0",
-                 reason = "use `fmt::String` (`{}` format specifier)")]
+                 reason = "use `fmt::Display` (`{}` format specifier)")]
     pub fn to_err_msg(self) -> String {
         self.to_string()
     }
@@ -579,7 +579,7 @@ impl fmt::Display for Fail {
 /// `opt_str`, etc. to interrogate results.
 /// # Panics
 ///
-/// Returns `Err(Fail)` on failure: use the `Show` implementation of `Fail` to display
+/// Returns `Err(Fail)` on failure: use the `Debug` implementation of `Fail` to display
 /// information about it.
 pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();

branches/auto/src/librustc/diagnostics.rs

@@ -126,8 +126,7 @@ register_diagnostics! {
     E0312, // lifetime of reference outlives lifetime of borrowed content
     E0313, // lifetime of borrowed pointer outlives lifetime of captured variable
     E0314, // closure outlives stack frame
-    E0315, // cannot invoke closure outside of its lifetime
-    E0316 // nested quantification of lifetimes
+    E0315 // cannot invoke closure outside of its lifetime
 }
 
 __build_diagnostic_array! { DIAGNOSTICS }

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

@@ -26,7 +26,7 @@ use syntax::ast;
 use syntax::abi;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
-use syntax::codemap::{Span, mk_sp};
+use syntax::codemap::{COMMAND_LINE_SP, Span, mk_sp};
 use syntax::parse;
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
@@ -457,13 +457,13 @@ impl<'a> CrateReader<'a> {
             CrateOrString::Krate(c) => {
                 (self.extract_crate_info(c).unwrap(), c.span)
             }
-            CrateOrString::Str(sp, s) => {
+            CrateOrString::Str(s) => {
                 (CrateInfo {
                      name: s.to_string(),
                      ident: s.to_string(),
                      id: ast::DUMMY_NODE_ID,
                      should_link: true,
-                 }, sp)
+                 }, COMMAND_LINE_SP)
             }
         };
         let target_triple = &self.sess.opts.target_triple[];
@@ -531,7 +531,7 @@ impl<'a> CrateReader<'a> {
 #[derive(Copy)]
 pub enum CrateOrString<'a> {
     Krate(&'a ast::Item),
-    Str(Span, &'a str)
+    Str(&'a str)
 }
 
 impl<'a> PluginMetadata<'a> {

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

@@ -50,10 +50,7 @@ pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {
     let any_exe = session.crate_types.borrow().iter().any(|ty| {
         *ty == config::CrateTypeExecutable
     });
-    let emit_link = session.opts.output_types.iter().any(|ty| {
-        *ty == config::OutputTypeExe
-    });
-    if !any_exe || !emit_link {
+    if !any_exe {
         // No need to find a main function
         return
     }