---

yaml
---
r: 130959
b: refs/heads/auto
c: 76c02af
h: refs/heads/master
i:
  130957: d150702
  130955: 29a2df4
  130951: 11dd2c0
  130943: 181bf2a
v: v3

Author: vadimcn

[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: d24c82420bf7c3c57376c5064d1195c22023715d
+refs/heads/auto: 76c02af434a7447824b3c0c105c4af57d3d6c50e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/docs.mk

@@ -76,22 +76,21 @@ endif
 
 # Check for the various external utilities for the EPUB/PDF docs:
 
-ifeq ($(CFG_LUALATEX),)
-  $(info cfg: no lualatex found, deferring to xelatex)
+ifeq ($(CFG_PDFLATEX),)
+  $(info cfg: no pdflatex 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)
+    $(info cfg: no xelatex found, deferring to lualatex)
+    ifeq ($(CFG_LUALATEX),)
+      $(info cfg: no lualatex found, disabling LaTeX docs)
       NO_PDF_DOCS = 1
 	else
-      CFG_LATEX := $(CFG_PDFLATEX)
+      CFG_LATEX := $(CFG_LUALATEX)
     endif
   else
     CFG_LATEX := $(CFG_XELATEX)
-    XELATEX = 1
   endif
 else
-  CFG_LATEX := $(CFG_LUALATEX)
+  CFG_LATEX := $(CFG_PDFLATEX)
 endif
 
 
@@ -188,25 +187,12 @@ doc/$(1).tex: $$(D)/$(1).md doc/footer.tex doc/version.tex | doc/
 ifneq ($(NO_PDF_DOCS),1)
 ifeq ($$(SHOULD_BUILD_PDF_DOC_$(1)),1)
 DOC_TARGETS += doc/$(1).pdf
-ifneq ($(XELATEX),1)
 doc/$(1).pdf: doc/$(1).tex
 	@$$(call E, latex compiler: $$@)
 	$$(Q)$$(CFG_LATEX) \
 	-interaction=batchmode \
 	-output-directory=doc \
 	$$<
-else
-# The version of xelatex on the snap bots seemingly ingores -output-directory
-# So we'll output to . and move to the doc directory manually.
-# This will leave some intermediate files in the build directory.
-doc/$(1).pdf: doc/$(1).tex
-	@$$(call E, latex compiler: $$@)
-	$$(Q)$$(CFG_LATEX) \
-	-interaction=batchmode \
-	-output-directory=. \
-	$$<
-	$$(Q)mv ./$(1).pdf $$@
-endif # XELATEX
 endif # SHOULD_BUILD_PDF_DOCS_$(1)
 endif # NO_PDF_DOCS
 

branches/auto/src/doc/index.md

@@ -43,10 +43,6 @@ discussion about Rust.
 There is also a [developer forum](http://discuss.rust-lang.org/), where the
 development of Rust itself is discussed.
 
-# Specification
-
-Rust does not have an exact specification, but an effort to describe as much of
-the language in as much detail as possible is in [the manual](rust.html).
 
 # Guides
 

branches/auto/src/doc/rust.md

@@ -349,7 +349,7 @@ 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.
+It is equivalent to a `&'static [u8]` borrowed vector 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
@@ -2555,8 +2555,6 @@ The currently implemented features of the reference compiler are:
                         which is considered wildly unsafe and will be
                         obsoleted by language improvements.
 
-* `tuple_indexing` - Allows use of tuple indexing (expressions like `expr.0`)
-
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
 the new feature (because the directive is no longer necessary). However, if
@@ -2811,17 +2809,16 @@ When the type providing the field inherits mutabilty, it can be [assigned](#assi
 Also, if the type of the expression to the left of the dot is a pointer,
 it is automatically dereferenced to make the field access possible.
 
-### Array expressions
+### Vector expressions
 
 ~~~~ {.ebnf .gram}
-array_expr : '[' "mut" ? vec_elems? ']' ;
+vec_expr : '[' "mut" ? vec_elems? ']' ;
 
-array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
+vec_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ~~~~
 
-An [array](#vector,-array,-and-slice-types) _expression_ is written by
-enclosing zero or more comma-separated expressions of uniform type in square
-brackets.
+A [_vector_](#vector-types) _expression_ is written by enclosing zero or
+more comma-separated expressions of uniform type in square brackets.
 
 In the `[expr ',' ".." expr]` form, the expression after the `".."`
 must be a constant expression that can be evaluated at compile time, such
@@ -2830,7 +2827,7 @@ as a [literal](#literals) or a [static item](#static-items).
 ~~~~
 [1i, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0i, ..128];             // array with 128 zeros
+[0i, ..128];             // vector with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ~~~~
 
@@ -2840,9 +2837,9 @@ as a [literal](#literals) or a [static item](#static-items).
 idx_expr : expr '[' expr ']' ;
 ~~~~
 
-[Array](#vector,-array,-and-slice-types)-typed expressions can be indexed by writing a
+[Vector](#vector-types)-typed expressions can be indexed by writing a
 square-bracket-enclosed expression (the index) after them. When the
-array is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can be assigned to.
+vector is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can be assigned to.
 
 Indices are zero-based, and may be of any integral type. Vector access
 is bounds-checked at run-time. When the check fails, it will put the
@@ -2903,7 +2900,7 @@ This means that arithmetic operators can be overridden for user-defined types.
 The default meaning of the operators on standard types is given here.
 
 * `+`
-  : Addition and array/string concatenation.
+  : Addition and vector/string concatenation.
     Calls the `add` method on the `std::ops::Add` trait.
 * `-`
   : Subtraction.
@@ -3206,7 +3203,7 @@ for_expr : "for" pat "in" no_struct_literal_expr '{' block '}' ;
 A `for` expression is a syntactic construct for looping over elements
 provided by an implementation of `std::iter::Iterator`.
 
-An example of a for loop over the contents of an array:
+An example of a for loop over the contents of a vector:
 
 ~~~~
 # type Foo = int;
@@ -3264,7 +3261,7 @@ match_pat : pat [ '|' pat ] * [ "if" expr ] ? ;
 
 A `match` expression branches on a *pattern*. The exact form of matching that
 occurs depends on the pattern. Patterns consist of some combination of
-literals, destructured arrays or enum constructors, structures and
+literals, destructured vectors or enum constructors, structures and
 tuples, variable binding specifications, wildcards (`..`), and placeholders
 (`_`). A `match` expression has a *head expression*, which is the value to
 compare to the patterns. The type of the patterns must equal the type of the
@@ -3293,11 +3290,11 @@ between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
 exactly one argument, while the pattern `C(..)` is type-correct for any enum
 variant `C`, regardless of how many arguments `C` has.
 
-Used inside a array pattern, `..` stands for any number of elements, when the
+Used inside a vector pattern, `..` stands for any number of elements, when the
 `advanced_slice_patterns` feature gate is turned on. This wildcard can be used
-at most once for a given array, which implies that it cannot be used to
+at most once for a given vector, which implies that it cannot be used to
 specifically match elements that are at an unknown distance from both ends of a
-array, like `[.., 42, ..]`.  If followed by a variable name, it will bind the
+vector, like `[.., 42, ..]`.  If followed by a variable name, it will bind the
 corresponding slice to the variable.  Example:
 
 ~~~~
@@ -3430,7 +3427,7 @@ let message = match x {
 ~~~~
 
 Range patterns only work on scalar types
-(like integers and characters; not like arrays and structs, which have sub-components).
+(like integers and characters; not like vectors and structs, which have sub-components).
 A range pattern may not be a sub-range of another range pattern inside the same `match`.
 
 Finally, match patterns can accept *pattern guards* to further refine the
@@ -3538,10 +3535,10 @@ http://www.unicode.org/glossary/#unicode_scalar_value)
 (ie. a code point that is not a surrogate),
 represented as a 32-bit unsigned word in the 0x0000 to 0xD7FF
 or 0xE000 to 0x10FFFF range.
-A `[char]` array is effectively an UCS-4 / UTF-32 string.
+A `[char]` vector is effectively an UCS-4 / UTF-32 string.
 
 A value of type `str` is a Unicode string,
-represented as a array of 8-bit unsigned bytes holding a sequence of UTF-8 codepoints.
+represented as a vector of 8-bit unsigned bytes holding a sequence of UTF-8 codepoints.
 Since `str` is of unknown size, it is not a _first class_ type,
 but can only be instantiated through a pointer type,
 such as `&str` or `String`.
@@ -3652,7 +3649,7 @@ Such recursion has restrictions:
 
 * Recursive types must include a nominal type in the recursion
   (not mere [type definitions](#type-definitions),
-   or other structural types such as [arrays](#vector,-array,-and-slice-types) or [tuples](#tuple-types)).
+   or other structural types such as [vectors](#vector-types) or [tuples](#tuple-types)).
 * A recursive `enum` item must have at least one non-recursive constructor
   (in order to give the recursion a basis case).
 * The size of a recursive type must be finite;
@@ -4156,7 +4153,7 @@ heap data.
 ### Built in types
 
 The runtime provides C and Rust code to assist with various built-in types,
-such as arrays, strings, and the low level communication system (ports,
+such as vectors, strings, and the low level communication system (ports,
 channels, tasks).
 
 Support for other built-in types such as simple types, tuples and

branches/auto/src/liballoc/heap.rs

@@ -12,6 +12,7 @@
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
 //                and `nonnull`
 
+use core::ptr::RawPtr;
 #[cfg(not(test))] use core::raw;
 #[cfg(stage0, not(test))] use util;
 
@@ -69,6 +70,11 @@ pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint,
 /// the value returned by `usable_size` for the requested size.
 #[inline]
 pub unsafe fn deallocate(ptr: *mut u8, size: uint, align: uint) {
+    // FIXME(14395) This is only required for DST ~[T], it should be removed once
+    // we fix that representation to not use null pointers.
+    if ptr.is_null() {
+        return;
+    }
     imp::deallocate(ptr, size, align)
 }
 

branches/auto/src/librustc/back/link.rs

@@ -929,6 +929,9 @@ fn link_args(cmd: &mut Command,
         cmd.arg("-nodefaultlibs");
     }
 
+    // Rust does its' own LTO
+    cmd.arg("-fno-lto").arg("-fno-use-linker-plugin");
+
     // If we're building a dylib, we don't use --gc-sections because LLVM has
     // already done the best it can do, and we also don't want to eliminate the
     // metadata. If we're building an executable, however, --gc-sections drops

branches/auto/src/librustc/front/feature_gate.rs

@@ -70,7 +70,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("unboxed_closures", Active),
     ("import_shadowing", Active),
     ("advanced_slice_patterns", Active),
-    ("tuple_indexing", Active),
 
     // if you change this list without updating src/doc/rust.md, cmr will be sad
 
@@ -339,11 +338,6 @@ impl<'a> Visitor<()> for Context<'a> {
                                   "unboxed closures are a work-in-progress \
                                    feature with known bugs");
             }
-            ast::ExprTupField(..) => {
-                self.gate_feature("tuple_indexing",
-                                  e.span,
-                                  "tuple indexing is experimental");
-            }
             _ => {}
         }
         visit::walk_expr(self, e, ());

branches/auto/src/librustc/front/show_span.rs

@@ -28,10 +28,6 @@ impl<'a> Visitor<()> for ShowSpanVisitor<'a> {
         self.sess.span_note(e.span, "expression");
         visit::walk_expr(self, e, ());
     }
-
-    fn visit_mac(&mut self, macro: &ast::Mac, e: ()) {
-        visit::walk_mac(self, macro, e);
-    }
 }
 
 pub fn run(sess: &Session, krate: &ast::Crate) {

branches/auto/src/librustc/lint/builtin.rs

@@ -1056,7 +1056,6 @@ impl UnnecessaryParens {
                 ast::ExprUnary(_, ref x) |
                 ast::ExprCast(ref x, _) |
                 ast::ExprField(ref x, _, _) |
-                ast::ExprTupField(ref x, _, _) |
                 ast::ExprIndex(ref x, _) => {
                     // &X { y: 1 }, X { y: 1 }.y
                     contains_exterior_struct_lit(&**x)

branches/auto/src/librustc/middle/borrowck/mod.rs

@@ -807,7 +807,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         out.push_str(token::get_name(fname).get());
                     }
                     mc::PositionalField(idx) => {
-                        out.push_char('.');
+                        out.push_char('#'); // invent a notation here
                         out.push_str(idx.to_string().as_slice());
                     }
                 }

branches/auto/src/librustc/middle/cfg/construct.rs

@@ -467,8 +467,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             ast::ExprCast(e, _) |
             ast::ExprUnary(_, e) |
             ast::ExprParen(e) |
-            ast::ExprField(e, _, _) |
-            ast::ExprTupField(e, _, _) => {
+            ast::ExprField(e, _, _) => {
                 self.straightline(expr, pred, [e])
             }
 

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

@@ -173,7 +173,6 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) {
           ExprAddrOf(MutImmutable, _) |
           ExprParen(..) |
           ExprField(..) |
-          ExprTupField(..) |
           ExprIndex(..) |
           ExprTup(..) |
           ExprRepeat(..) |

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

@@ -106,7 +106,7 @@ impl<'a, 'tcx> Visitor<bool> for CheckStaticVisitor<'a, 'tcx> {
         }
 
         match e.node {
-            ast::ExprField(..) | ast::ExprTupField(..) | ast::ExprVec(..) |
+            ast::ExprField(..) | ast::ExprVec(..) |
             ast::ExprBlock(..) | ast::ExprTup(..)  => {
                 visit::walk_expr(self, e, is_const);
             }

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

@@ -225,8 +225,6 @@ impl<'a, 'tcx> ConstEvalVisitor<'a, 'tcx> {
 
             ast::ExprField(ref base, _, _) => self.classify(&**base),
 
-            ast::ExprTupField(ref base, _, _) => self.classify(&**base),
-
             ast::ExprIndex(ref base, ref idx) =>
                 join(self.classify(&**base), self.classify(&**idx)),
 

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

@@ -145,17 +145,6 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
         }
     }
 
-    fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: uint) {
-        match ty::get(ty::expr_ty_adjusted(self.tcx, lhs)).sty {
-            ty::ty_struct(id, _) => {
-                let fields = ty::lookup_struct_fields(self.tcx, id);
-                let field_id = fields[idx].id;
-                self.live_symbols.insert(field_id.node);
-            },
-            _ => ()
-        }
-    }
-
     fn handle_field_pattern_match(&mut self, lhs: &ast::Pat, pats: &[ast::FieldPat]) {
         let id = match self.tcx.def_map.borrow().get(&lhs.id) {
             &def::DefVariant(_, id, _) => id,
@@ -266,9 +255,6 @@ impl<'a, 'tcx> Visitor<MarkSymbolVisitorContext> for MarkSymbolVisitor<'a, 'tcx>
             ast::ExprField(ref lhs, ref ident, _) => {
                 self.handle_field_access(&**lhs, &ident.node);
             }
-            ast::ExprTupField(ref lhs, idx, _) => {
-                self.handle_tup_field_access(&**lhs, idx.node);
-            }
             _ => ()
         }
 

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

@@ -324,10 +324,6 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
                 self.select_from_expr(&**base);
             }
 
-            ast::ExprTupField(ref base, _, _) => {         // base.<n>
-                self.select_from_expr(&**base);
-            }
-
             ast::ExprIndex(ref lhs, ref rhs) => {           // lhs[rhs]
                 if !self.walk_overloaded_operator(expr, &**lhs, [rhs.clone()]) {
                     self.select_from_expr(&**lhs);