---

yaml
---
r: 209582
b: refs/heads/try
c: 966e53d
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: efa6a46a8eceb4ab792d5ec8e28cf3baaaa96491
+refs/heads/try: 966e53d8b6272a324c6be3460ae6bf52e47202fe
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/crates.mk

@@ -54,7 +54,8 @@ TARGET_CRATES := libc std flate arena term \
                  log graphviz core rbml alloc \
                  unicode rustc_bitflags
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
-                rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint
+                rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
+                rustc_data_structures
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc rustbook
@@ -80,9 +81,10 @@ DEPS_rustc_resolve := rustc log syntax
 DEPS_rustc_privacy := rustc log syntax
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
-              log graphviz rustc_llvm rustc_back
+              log graphviz rustc_llvm rustc_back rustc_data_structures
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
+DEPS_rustc_data_structures := std log serialize
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint
 DEPS_rustc_bitflags := core

branches/try/src/doc/trpl/hello-cargo.md

@@ -89,7 +89,7 @@ we hadn’t changed the source file, and so it just ran the binary. If we had
 made a modification, we would have seen it do both:
 
 ```bash
-$ cargo run
+$ cargo build
    Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world)
      Running `target/debug/hello_world`
 Hello, world!

branches/try/src/doc/trpl/vectors.md

@@ -1,18 +1,13 @@
 % Vectors
 
 A *vector* is a dynamic or "growable" array, implemented as the standard
-library type [`Vec<T>`](../std/vec/) (Where `<T>` is a [Generic](./generics.md)
-statement). Vectors always allocate their data on the heap. Vectors are to
-[slices][slices] what [`String`][string] is to `&str`. You can
-create them with the `vec!` macro:
+library type [`Vec<T>`](../std/vec/) (Where `<T>` is a [Generic](./generics.md) statement). Vectors always allocate their data on the heap. Vectors are to slices
+what `String` is to `&str`. You can create them with the `vec!` macro:
 
 ```{rust}
 let v = vec![1, 2, 3]; // v: Vec<i32>
 ```
 
-[slices]: primitive-types.html#slices
-[string]: strings.html
-
 (Notice that unlike the `println!` macro we've used in the past, we use square
 brackets `[]` with `vec!`. Rust allows you to use either in either situation,
 this is just convention.)

branches/try/src/libcore/num/mod.rs

@@ -1321,11 +1321,7 @@ macro_rules! int_impl {
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
         pub fn abs(self) -> $T {
-            if self.is_negative() {
-                self.wrapping_neg()
-            } else {
-                self
-            }
+            if self.is_negative() { -self } else { self }
         }
 
         /// Returns a number representing sign of `self`.

branches/try/src/libcore/ops.rs

@@ -969,7 +969,7 @@ pub struct RangeFull;
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for RangeFull {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "..")
+        fmt::Debug::fmt("..", fmt)
     }
 }
 

branches/try/src/librustc/lib.rs

@@ -54,6 +54,7 @@ extern crate graphviz;
 extern crate libc;
 extern crate rustc_llvm;
 extern crate rustc_back;
+extern crate rustc_data_structures;
 extern crate serialize;
 extern crate rbml;
 extern crate collections;

branches/try/src/librustc/metadata/tydecode.rs

@@ -341,12 +341,7 @@ fn parse_region_<F>(st: &mut PState, conv: &mut F) -> ty::Region where
         let index = parse_u32(st);
         assert_eq!(next(st), '|');
         let nm = token::str_to_ident(&parse_str(st, ']'));
-        ty::ReEarlyBound(ty::EarlyBoundRegion {
-            param_id: node_id,
-            space: space,
-            index: index,
-            name: nm.name
-        })
+        ty::ReEarlyBound(node_id, space, index, nm.name)
       }
       'f' => {
         assert_eq!(next(st), '[');

branches/try/src/librustc/metadata/tyencode.rs

@@ -241,12 +241,12 @@ pub fn enc_region(w: &mut Encoder, cx: &ctxt, r: ty::Region) {
             enc_bound_region(w, cx, br);
             mywrite!(w, "]");
         }
-        ty::ReEarlyBound(ref data) => {
+        ty::ReEarlyBound(node_id, space, index, name) => {
             mywrite!(w, "B[{}|{}|{}|{}]",
-                     data.param_id,
-                     data.space.to_uint(),
-                     data.index,
-                     token::get_name(data.name));
+                     node_id,
+                     space.to_uint(),
+                     index,
+                     token::get_name(name));
         }
         ty::ReFree(ref fr) => {
             mywrite!(w, "f[");

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

@@ -496,13 +496,8 @@ impl tr for ty::Region {
             ty::ReLateBound(debruijn, br) => {
                 ty::ReLateBound(debruijn, br.tr(dcx))
             }
-            ty::ReEarlyBound(data) => {
-                ty::ReEarlyBound(ty::EarlyBoundRegion {
-                    param_id: dcx.tr_id(data.param_id),
-                    space: data.space,
-                    index: data.index,
-                    name: data.name,
-                })
+            ty::ReEarlyBound(id, space, index, ident) => {
+                ty::ReEarlyBound(dcx.tr_id(id), space, index, ident)
             }
             ty::ReScope(scope) => {
                 ty::ReScope(scope.tr(dcx))

branches/try/src/librustc/middle/region.rs

@@ -603,11 +603,14 @@ impl RegionMaps {
                     self.sub_free_region(sub_fr, super_fr)
                 }
 
-                (ty::ReEarlyBound(data_a), ty::ReEarlyBound(data_b)) => {
+                (ty::ReEarlyBound(param_id_a, param_space_a, index_a, _),
+                 ty::ReEarlyBound(param_id_b, param_space_b, index_b, _)) => {
                     // This case is used only to make sure that explicitly-
                     // specified `Self` types match the real self type in
-                    // implementations. Yuck.
-                    data_a == data_b
+                    // implementations.
+                    param_id_a == param_id_b &&
+                        param_space_a == param_space_b &&
+                        index_a == index_b
                 }
 
                 _ => {

branches/try/src/librustc/middle/subst.rs

@@ -622,11 +622,11 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
         // regions that appear in a function signature is done using
         // the specialized routine `ty::replace_late_regions()`.
         match r {
-            ty::ReEarlyBound(data) => {
+            ty::ReEarlyBound(_, space, i, region_name) => {
                 match self.substs.regions {
                     ErasedRegions => ty::ReStatic,
                     NonerasedRegions(ref regions) =>
-                        match regions.opt_get(data.space, data.index as usize) {
+                        match regions.opt_get(space, i as usize) {
                             Some(&r) => {
                                 self.shift_region_through_binders(r)
                             }
@@ -635,12 +635,11 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
                                 self.tcx().sess.span_bug(
                                     span,
                                     &format!("Type parameter out of range \
-                                              when substituting in region {} (root type={}) \
-                                              (space={:?}, index={})",
-                                             data.name.as_str(),
-                                             self.root_ty.repr(self.tcx()),
-                                             data.space,
-                                             data.index));
+                                     when substituting in region {} (root type={}) \
+                                     (space={:?}, index={})",
+                                    region_name.as_str(),
+                                    self.root_ty.repr(self.tcx()),
+                                    space, i));
                             }
                         }
                 }

branches/try/src/librustc/middle/ty.rs

@@ -1134,7 +1134,10 @@ pub enum Region {
     // Region bound in a type or fn declaration which will be
     // substituted 'early' -- that is, at the same time when type
     // parameters are substituted.
-    ReEarlyBound(EarlyBoundRegion),
+    ReEarlyBound(/* param id */ ast::NodeId,
+                 subst::ParamSpace,
+                 /*index*/ u32,
+                 ast::Name),
 
     // Region bound in a function scope, which will be substituted when the
     // function is called.
@@ -1166,14 +1169,6 @@ pub enum Region {
     ReEmpty,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)]
-pub struct EarlyBoundRegion {
-    pub param_id: ast::NodeId,
-    pub space: subst::ParamSpace,
-    pub index: u32,
-    pub name: ast::Name,
-}
-
 /// Upvars do not get their own node-id. Instead, we use the pair of
 /// the original var id (that is, the root variable that is referenced
 /// by the upvar) and the id of the closure expression.
@@ -1766,12 +1761,7 @@ pub struct RegionParameterDef {
 
 impl RegionParameterDef {
     pub fn to_early_bound_region(&self) -> ty::Region {
-        ty::ReEarlyBound(ty::EarlyBoundRegion {
-            param_id: self.def_id.node,
-            space: self.space,
-            index: self.index,
-            name: self.name,
-        })
+        ty::ReEarlyBound(self.def_id.node, self.space, self.index, self.name)
     }
     pub fn to_bound_region(&self) -> ty::BoundRegion {
         ty::BoundRegion::BrNamed(self.def_id, self.name)
@@ -7081,7 +7071,8 @@ pub fn make_substs_for_receiver_types<'tcx>(tcx: &ty::ctxt<'tcx>,
     let meth_regions: Vec<ty::Region> =
         method.generics.regions.get_slice(subst::FnSpace)
               .iter()
-              .map(|def| def.to_early_bound_region())
+              .map(|def| ty::ReEarlyBound(def.def_id.node, def.space,
+                                          def.index, def.name))
               .collect();
     trait_ref.substs.clone().with_method(meth_tps, meth_regions)
 }

branches/try/src/librustc/session/config.rs

@@ -606,8 +606,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
           "Force overflow checks on or off"),
     force_dropflag_checks: Option<bool> = (None, parse_opt_bool,
           "Force drop flag checks on or off"),
-    trace_macros: bool = (false, parse_bool,
-          "For every macro invocation, print its name and arguments"),
 }
 
 pub fn default_lib_output() -> CrateType {
@@ -669,7 +667,7 @@ pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
         Ok(t) => t,
         Err(e) => {
             sp.handler().fatal(&format!("Error loading target specification: {}", e));
-        }
+    }
     };
 
     let (int_type, uint_type) = match &target.target_pointer_width[..] {

branches/try/src/librustc/util/ppaux.rs

@@ -163,8 +163,8 @@ pub fn explain_region_and_span(cx: &ctxt, region: ty::Region)
 
       ReEmpty => { ("the empty lifetime".to_string(), None) }
 
-      ReEarlyBound(ref data) => {
-        (format!("{}", token::get_name(data.name)), None)
+      ReEarlyBound(_, _, _, name) => {
+        (format!("{}", token::get_name(name)), None)
       }
 
       // I believe these cases should not occur (except when debugging,
@@ -223,8 +223,8 @@ pub fn region_to_string(cx: &ctxt, prefix: &str, space: bool, region: Region) ->
     // `explain_region()` or `note_and_explain_region()`.
     match region {
         ty::ReScope(_) => prefix.to_string(),
-        ty::ReEarlyBound(ref data) => {
-            token::get_name(data.name).to_string()
+        ty::ReEarlyBound(_, _, _, name) => {
+            token::get_name(name).to_string()
         }
         ty::ReLateBound(_, br) => bound_region_to_string(cx, prefix, space, br),
         ty::ReFree(ref fr) => bound_region_to_string(cx, prefix, space, fr.bound_region),
@@ -810,12 +810,8 @@ impl<'tcx> Repr<'tcx> for ty::TraitRef<'tcx> {
         // to enumerate the `for<...>` etc because the debruijn index
         // tells you everything you need to know.
         let base = ty::item_path_str(tcx, self.def_id);
-        let result = parameterized(tcx, &base, self.substs, self.def_id, &[],
-                      || ty::lookup_trait_def(tcx, self.def_id).generics.clone());
-        match self.substs.self_ty() {
-            None => result,
-            Some(sty) => format!("<{} as {}>", sty.repr(tcx), result)
-        }
+        parameterized(tcx, &base, self.substs, self.def_id, &[],
+                      || ty::lookup_trait_def(tcx, self.def_id).generics.clone())
     }
 }
 
@@ -903,12 +899,12 @@ impl<'tcx> Repr<'tcx> for ty::BoundRegion {
 impl<'tcx> Repr<'tcx> for ty::Region {
     fn repr(&self, tcx: &ctxt) -> String {
         match *self {
-            ty::ReEarlyBound(ref data) => {
+            ty::ReEarlyBound(id, space, index, name) => {
                 format!("ReEarlyBound({}, {:?}, {}, {})",
-                        data.param_id,
-                        data.space,
-                        data.index,
-                        token::get_name(data.name))
+                               id,
+                               space,
+                               index,
+                               token::get_name(name))
             }
 
             ty::ReLateBound(binder_id, ref bound_region) => {
@@ -1508,7 +1504,8 @@ impl<'tcx> UserString<'tcx> for ty::ProjectionPredicate<'tcx> {
 
 impl<'tcx> Repr<'tcx> for ty::ProjectionTy<'tcx> {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        format!("{}::{}",
+        format!("<{} as {}>::{}",
+                self.trait_ref.substs.self_ty().repr(tcx),
                 self.trait_ref.repr(tcx),
                 self.item_name.repr(tcx))
     }

branches/try/src/librustc_data_structures/lib.rs

@@ -0,0 +1,33 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Various data structures used by the Rust compiler. The intention
+//! is that code in here should be not be *specific* to rustc, so that
+//! it can be easily unit tested and so forth.
+//!
+//! # Note
+//!
+//! This API is completely unstable and subject to change.
+
+// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
+#![cfg_attr(stage0, feature(custom_attribute))]
+#![crate_name = "rustc_data_structures"]
+#![unstable(feature = "rustc_private")]
+#![crate_type = "dylib"]
+#![crate_type = "rlib"]
+#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      html_root_url = "http://doc.rust-lang.org/nightly/")]
+
+#![feature(rustc_private)]
+#![feature(test)]
+
+#[macro_use] extern crate log;
+extern crate serialize as rustc_serialize; // used by deriving

branches/try/src/librustc_driver/driver.rs

@@ -483,7 +483,6 @@ pub fn phase_2_configure_and_expand(sess: &Session,
                 crate_name: crate_name.to_string(),
                 features: Some(&features),
                 recursion_limit: sess.recursion_limit.get(),
-                trace_mac: sess.opts.debugging_opts.trace_macros,
             };
             let ret = syntax::ext::expand::expand_crate(&sess.parse_sess,
                                               cfg,

branches/try/src/librustc_driver/test.rs

@@ -290,12 +290,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
                           -> ty::Region
     {
         let name = token::intern(name);
-        ty::ReEarlyBound(ty::EarlyBoundRegion {
-            param_id: ast::DUMMY_NODE_ID,
-            space: space,
-            index: index,
-            name: name
-        })
+        ty::ReEarlyBound(ast::DUMMY_NODE_ID, space, index, name)
     }
 
     pub fn re_late_bound_with_debruijn(&self, id: u32, debruijn: ty::DebruijnIndex) -> ty::Region {