---

yaml
---
r: 234415
b: refs/heads/tmp
c: 5441ad6
h: refs/heads/master
i:
  234413: 4e5f840
  234411: 0dd2747
  234407: 5b59ab4
  234399: 825f8be
v: v3

Author: steveklabnik

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: a7f4a8e50da5525ff44fd61fb2c8f67e92eb072d
+refs/heads/tmp: 5441ad6b9d944d0e625bed87e1e3ff169a268390
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/mk/crates.mk

@@ -54,7 +54,7 @@ TARGET_CRATES := libc std flate arena term \
                  log graphviz core rbml alloc \
                  rustc_unicode rustc_bitflags \
 		 alloc_system
-RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
+RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
@@ -70,12 +70,11 @@ DEPS_std := core libc rand alloc collections rustc_unicode \
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc rustc_bitflags
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
-                     rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \
+                     rustc_typeck rustc_resolve log syntax serialize rustc_llvm \
 		             rustc_trans rustc_privacy rustc_lint rustc_front
 
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
 	                log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics
-DEPS_rustc_mir := rustc rustc_front syntax
 DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics
 DEPS_rustc_borrowck := rustc rustc_front log graphviz syntax
 DEPS_rustc_resolve := rustc rustc_front log syntax

branches/tmp/mk/main.mk

@@ -172,18 +172,6 @@ RUST_LIB_FLAGS_ST3 += -C prefer-dynamic
 # by not emitting them.
 RUSTFLAGS_STAGE0 += -Z no-landing-pads
 
-# Enable MIR to "always build" for crates where this works. This is
-# just temporary while MIR is being actively built up -- it's just a
-# poor man's unit testing infrastructure. Anyway we only want this for
-# stage1/stage2.
-define ADD_MIR_FLAG
-RUSTFLAGS1_$(1) += -Z always-build-mir
-RUSTFLAGS2_$(1) += -Z always-build-mir
-endef
-$(foreach crate,$(TARGET_CRATES),$(eval $(call ADD_MIR_FLAG,$(crate))))
-$(foreach crate,$(RUSTC_CRATES),$(eval $(call ADD_MIR_FLAG,$(crate))))
-$(foreach crate,$(HOST_CRATES),$(eval $(call ADD_MIR_FLAG,$(crate))))
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/tmp/mk/target.mk

@@ -93,7 +93,6 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 		$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
 		$$(LLVM_STDCPP_RUSTFLAGS_$(2)) \
 		$$(RUSTFLAGS_$(4)) \
-		$$(RUSTFLAGS$(1)_$(4)) \
 		$$(RUSTFLAGS$(1)_$(4)_T_$(2)) \
 		--out-dir $$(@D) \
 		-C extra-filename=-$$(CFG_FILENAME_EXTRA) \

branches/tmp/src/doc/index.md

@@ -20,30 +20,13 @@ series of small examples.
 
 [rbe]: http://rustbyexample.com/
 
-# Language Reference
-
-Rust does not have an exact specification yet, but an effort to describe as much of
-the language in as much detail as possible is in [the reference](reference.html).
-
-# Standard Library Reference
+# The Standard Library
 
 We have [API documentation for the entire standard
 library](std/index.html). There's a list of crates on the left with more
 specific sections, or you can use the search bar at the top to search for
 something if you know its name.
 
-# Tools
-
-[Cargo](https://crates.io) is the Rust's package manager providing access to libraries
-beyond the standard one, and its website contains lots of good documentation.
-
-[`rustdoc`](book/documentation.html) is the Rust's documentation generator, a tool converting
-annotated source code into HTML docs.
-
-A bunch of non-official tools are available, such as [Racer](https://github.com/phildawes/racer)
-(code completion engine), or [rustfmt](https://github.com/nrc/rustfmt) (source code formatter),
-or text editor plugins.
-
 # Community & Getting Help
 
 If you need help with something, or just want to talk about Rust with others,
@@ -71,10 +54,25 @@ There is an active [subreddit](https://reddit.com/r/rust) with lots of
 discussion and news about Rust.
 
 There is also a [user forum](https://users.rust-lang.org), for all
-user-oriented discussion, and a [developer
+user-oriented discussion, and a [developer 
 forum](https://internals.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 reference](reference.html).
+
+# Tools
+
+Rust is still a young language, so there isn't a ton of tooling yet, but the
+tools we have are really nice.
+
+[Cargo](https://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.
+
 # FAQs
 
 There are questions that are asked quite often, so we've made FAQs for them:

branches/tmp/src/doc/nomicon/vec-drain.md

@@ -129,16 +129,14 @@ impl<'a, T> Drop for Drain<'a, T> {
 
 impl<T> Vec<T> {
     pub fn drain(&mut self) -> Drain<T> {
-        unsafe {
-            let iter = RawValIter::new(&self);
-
-            // this is a mem::forget safety thing. If Drain is forgotten, we just
-            // leak the whole Vec's contents. Also we need to do this *eventually*
-            // anyway, so why not do it now?
-            self.len = 0;
+        // this is a mem::forget safety thing. If Drain is forgotten, we just
+        // leak the whole Vec's contents. Also we need to do this eventually
+        // anyway, so why not do it now?
+        self.len = 0;
 
+        unsafe {
             Drain {
-                iter: iter,
+                iter: RawValIter::new(&self),
                 vec: PhantomData,
             }
         }

branches/tmp/src/doc/nomicon/vec-final.md

@@ -155,16 +155,13 @@ impl<T> Vec<T> {
     }
 
     pub fn drain(&mut self) -> Drain<T> {
+        // this is a mem::forget safety thing. If this is forgotten, we just
+        // leak the whole Vec's contents. Also we need to do this *eventually*
+        // anyway, so why not do it now?
+        self.len = 0;
         unsafe {
-            let iter = RawValIter::new(&self);
-
-            // this is a mem::forget safety thing. If Drain is forgotten, we just
-            // leak the whole Vec's contents. Also we need to do this *eventually*
-            // anyway, so why not do it now?
-            self.len = 0;
-
             Drain {
-                iter: iter,
+                iter: RawValIter::new(&self),
                 vec: PhantomData,
             }
         }

branches/tmp/src/doc/trpl/advanced-linking.md

@@ -34,8 +34,8 @@ formal `#[link(...)]` attribute on `extern` blocks instead.
 
 # Static linking
 
-Static linking refers to the process of creating output that contains all
-required libraries and so doesn't need libraries installed on every system where
+Static linking refers to the process of creating output that contain all
+required libraries and so don't need libraries installed on every system where
 you want to use your compiled project. Pure-Rust dependencies are statically
 linked by default so you can use created binaries and libraries without
 installing Rust everywhere. By contrast, native libraries

branches/tmp/src/libcollections/macros.rs

@@ -32,12 +32,6 @@
 /// Note that unlike array expressions this syntax supports all elements
 /// which implement `Clone` and the number of elements doesn't have to be
 /// a constant.
-///
-/// This will use `clone()` to duplicate an expression, so one should be careful
-/// using this with types having a nonstandard `Clone` implementation. For
-/// example, `vec![Rc::new(1); 5]` will create a vector of five references
-/// to the same boxed integer value, not five references pointing to independently
-/// boxed integers.
 #[cfg(not(test))]
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]

branches/tmp/src/libcore/slice.rs

@@ -303,8 +303,10 @@ impl<T> SliceExt for [T] {
     fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
         let len = self.len();
         let ptr = self.as_mut_ptr();
-        assert!(mid <= len);
+
         unsafe {
+            assert!(mid <= len);
+
             (from_raw_parts_mut(ptr, mid),
              from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
         }

branches/tmp/src/libgraphviz/lib.rs

@@ -313,13 +313,6 @@ pub enum LabelText<'a> {
     /// are also the escape sequences `\l` which left-justifies the
     /// preceding line and `\r` which right-justifies it.
     EscStr(Cow<'a, str>),
-
-    /// This uses a graphviz [HTML string label][html]. The string is
-    /// printed exactly as given, but between `<` and `>`. **No
-    /// escaping is performed.**
-    ///
-    /// [html]: http://www.graphviz.org/content/node-shapes#html
-    HtmlStr(Cow<'a, str>),
 }
 
 /// The style for a node or edge.
@@ -460,14 +453,6 @@ pub trait Labeller<'a,N,E> {
     /// is a valid DOT identifier.
     fn node_id(&'a self, n: &N) -> Id<'a>;
 
-    /// Maps `n` to one of the [graphviz `shape` names][1]. If `None`
-    /// is returned, no `shape` attribute is specified.
-    ///
-    /// [1]: http://www.graphviz.org/content/node-shapes
-    fn node_shape(&'a self, _node: &N) -> Option<LabelText<'a>> {
-        None
-    }
-
     /// Maps `n` to a label that will be used in the rendered output.
     /// The label need not be unique, and may be the empty string; the
     /// default is just the output from `node_id`.
@@ -494,16 +479,6 @@ pub trait Labeller<'a,N,E> {
     }
 }
 
-/// Escape tags in such a way that it is suitable for inclusion in a
-/// Graphviz HTML label.
-pub fn escape_html(s: &str) -> String {
-    s
-        .replace("&", "&amp;")
-        .replace("\"", "&quot;")
-        .replace("<", "&lt;")
-        .replace(">", "&gt;")
-}
-
 impl<'a> LabelText<'a> {
     pub fn label<S:IntoCow<'a, str>>(s: S) -> LabelText<'a> {
         LabelStr(s.into_cow())
@@ -513,10 +488,6 @@ impl<'a> LabelText<'a> {
         EscStr(s.into_cow())
     }
 
-    pub fn html<S:IntoCow<'a, str>>(s: S) -> LabelText<'a> {
-        HtmlStr(s.into_cow())
-    }
-
     fn escape_char<F>(c: char, mut f: F) where F: FnMut(char) {
         match c {
             // not escaping \\, since Graphviz escString needs to
@@ -534,12 +505,10 @@ impl<'a> LabelText<'a> {
     }
 
     /// Renders text as string suitable for a label in a .dot file.
-    /// This includes quotes or suitable delimeters.
-    pub fn to_dot_string(&self) -> String {
+    pub fn escape(&self) -> String {
         match self {
-            &LabelStr(ref s) => format!("\"{}\"", s.escape_default()),
-            &EscStr(ref s) => format!("\"{}\"", LabelText::escape_str(&s[..])),
-            &HtmlStr(ref s) => format!("<{}>", s),
+            &LabelStr(ref s) => s.escape_default(),
+            &EscStr(ref s) => LabelText::escape_str(&s[..]),
         }
     }
 
@@ -555,7 +524,6 @@ impl<'a> LabelText<'a> {
             } else {
                 s
             },
-            HtmlStr(s) => s,
         }
     }
 
@@ -644,15 +612,14 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N
         try!(indent(w));
         let id = g.node_id(n);
 
-        let escaped = &g.node_label(n).to_dot_string();
-        let shape;
+        let escaped = &g.node_label(n).escape();
 
         let mut text = vec![id.as_slice()];
 
         if !options.contains(&RenderOption::NoNodeLabels) {
-            text.push("[label=");
+            text.push("[label=\"");
             text.push(escaped);
-            text.push("]");
+            text.push("\"]");
         }
 
         let style = g.node_style(n);
@@ -662,19 +629,12 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N
             text.push("\"]");
         }
 
-        if let Some(s) = g.node_shape(n) {
-            shape = s.to_dot_string();
-            text.push("[shape=");
-            text.push(&shape);
-            text.push("]");
-        }
-
         text.push(";");
         try!(writeln(w, &text));
     }
 
     for e in g.edges().iter() {
-        let escaped_label = &g.edge_label(e).to_dot_string();
+        let escaped_label = &g.edge_label(e).escape();
         try!(indent(w));
         let source = g.source(e);
         let target = g.target(e);
@@ -684,9 +644,9 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N
         let mut text = vec![source_id.as_slice(), " -> ", target_id.as_slice()];
 
         if !options.contains(&RenderOption::NoEdgeLabels) {
-            text.push("[label=");
+            text.push("[label=\"");
             text.push(escaped_label);
-            text.push("]");
+            text.push("\"]");
         }
 
         let style = g.edge_style(e);
@@ -707,7 +667,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N
 mod tests {
     use self::NodeLabels::*;
     use super::{Id, Labeller, Nodes, Edges, GraphWalk, render, Style};
-    use super::LabelText::{self, LabelStr, EscStr, HtmlStr};
+    use super::LabelText::{self, LabelStr, EscStr};
     use std::io;
     use std::io::prelude::*;
     use std::borrow::IntoCow;
@@ -845,12 +805,12 @@ mod tests {
         fn node_id(&'a self, n: &Node) -> Id<'a> { self.graph.node_id(n) }
         fn node_label(&'a self, n: &Node) -> LabelText<'a> {
             match self.graph.node_label(n) {
-                LabelStr(s) | EscStr(s) | HtmlStr(s) => EscStr(s),
+                LabelStr(s) | EscStr(s) => EscStr(s),
             }
         }
         fn edge_label(&'a self, e: & &'a Edge) -> LabelText<'a> {
             match self.graph.edge_label(e) {
-                LabelStr(s) | EscStr(s) | HtmlStr(s) => EscStr(s),
+                LabelStr(s) | EscStr(s) => EscStr(s),
             }
         }
     }

branches/tmp/src/librustc/middle/astencode.rs

@@ -470,8 +470,8 @@ impl tr for def::Def {
           def::DefPrimTy(p) => def::DefPrimTy(p),
           def::DefTyParam(s, index, def_id, n) => def::DefTyParam(s, index, def_id.tr(dcx), n),
           def::DefUse(did) => def::DefUse(did.tr(dcx)),
-          def::DefUpvar(nid1, index, nid2) => {
-            def::DefUpvar(dcx.tr_id(nid1), index, dcx.tr_id(nid2))
+          def::DefUpvar(nid1, nid2) => {
+            def::DefUpvar(dcx.tr_id(nid1), dcx.tr_id(nid2))
           }
           def::DefStruct(did) => def::DefStruct(did.tr(dcx)),
           def::DefRegion(nid) => def::DefRegion(dcx.tr_id(nid)),

branches/tmp/src/librustc/middle/def.rs

@@ -38,7 +38,6 @@ pub enum Def {
     DefTyParam(ParamSpace, u32, DefId, ast::Name),
     DefUse(DefId),
     DefUpvar(ast::NodeId,  // id of closed over local
-             usize,        // index in the freevars list of the closure
              ast::NodeId), // expr node that creates the closure
 
     /// Note that if it's a tuple struct's definition, the node id of the DefId
@@ -130,7 +129,7 @@ impl Def {
                 id
             }
             DefLocal(id) |
-            DefUpvar(id, _, _) |
+            DefUpvar(id, _) |
             DefRegion(id) |
             DefLabel(id)  |
             DefSelfTy(_, Some((_, id))) => {

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

@@ -246,7 +246,7 @@ impl OverloadedCallType {
 pub struct ExprUseVisitor<'d, 't, 'a: 't, 'tcx:'a+'d+'t> {
     typer: &'t infer::InferCtxt<'a, 'tcx>,
     mc: mc::MemCategorizationContext<'t, 'a, 'tcx>,
-    delegate: &'d mut Delegate<'tcx>,
+    delegate: &'d mut (Delegate<'tcx>+'d),
 }
 
 // If the TYPER results in an error, it's because the type check