---

yaml
---
r: 69373
b: refs/heads/auto
c: df67942
h: refs/heads/master
i:
  69371: d3f66cb
v: v3

Author: luqmana

[refs]

@@ -14,6 +14,6 @@ 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: 5109ce691c5b8cc6c4ef189bec33e9131e2899bf
+refs/heads/auto: df67942dccc33379051e66f075615e579f3bdb49
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/doc/tutorial-container.md

@@ -108,14 +108,12 @@ impl Iterator<int> for ZeroStream {
 ## Container iterators
 
 Containers implement iteration over the contained elements by returning an
-iterator object. For example, vector slices several iterators available:
+iterator object. For example, vector slices have four iterators available:
 
-* `iter()` and `rev_iter()`, for immutable references to the elements
-* `mut_iter()` and `mut_rev_iter()`, for mutable references to the elements
-* `consume_iter()` and `consume_rev_iter`, to move the elements out by-value
-
-A typical mutable container will implement at least `iter()`, `mut_iter()` and
-`consume_iter()` along with the reverse variants if it maintains an order.
+* `vector.iter()`, for immutable references to the elements
+* `vector.mut_iter()`, for mutable references to the elements
+* `vector.rev_iter()`, for immutable references to the elements in reverse order
+* `vector.mut_rev_iter()`, for mutable references to the elements in reverse order
 
 ### Freezing
 

branches/auto/mk/tests.mk

@@ -537,10 +537,6 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # Rules for the cfail/rfail/rpass/bench/perf test runner
 
-# The tests select when to use debug configuration on their own;
-# remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS = $$(subst --cfg debug,,$$(CFG_RUSTC_FLAGS))
-
 CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
 		--compile-lib-path $$(HLIB$(1)_H_$(3))				\
         --run-lib-path $$(TLIB$(1)_T_$(2)_H_$(3))			\
@@ -552,7 +548,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         --target $(2)                                       \
         --adb-path=$(CFG_ADB)                          \
         --adb-test-dir=$(CFG_ADB_TEST_DIR)                  \
-        --rustcflags "$(RUSTC_FLAGS_$(2)) $$(CTEST_RUSTC_FLAGS) --target=$(2)" \
+        --rustcflags "$(RUSTC_FLAGS_$(2)) $$(CFG_RUSTC_FLAGS) --target=$(2)" \
         $$(CTEST_TESTARGS)
 
 CTEST_DEPS_rpass_$(1)-T-$(2)-H-$(3) = $$(RPASS_TESTS)

branches/auto/src/libextra/num/bigint.rs

@@ -732,11 +732,6 @@ impl Ord for Sign {
     }
 }
 
-impl TotalEq for Sign {
-    fn equals(&self, other: &Sign) -> bool {
-        *self == *other
-    }
-}
 impl TotalOrd for Sign {
 
     fn cmp(&self, other: &Sign) -> Ordering {

branches/auto/src/libextra/num/rational.rs

@@ -110,25 +110,6 @@ cmp_impl!(impl TotalEq, equals)
 cmp_impl!(impl Ord, lt, gt, le, ge)
 cmp_impl!(impl TotalOrd, cmp -> cmp::Ordering)
 
-impl<T: Clone + Integer + Ord> Orderable for Ratio<T> {
-    #[inline]
-    fn min(&self, other: &Ratio<T>) -> Ratio<T> {
-        if *self < *other { self.clone() } else { other.clone() }
-    }
-
-    #[inline]
-    fn max(&self, other: &Ratio<T>) -> Ratio<T> {
-        if *self > *other { self.clone() } else { other.clone() }
-    }
-
-    #[inline]
-    fn clamp(&self, mn: &Ratio<T>, mx: &Ratio<T>) -> Ratio<T> {
-        if *self > *mx { mx.clone()} else
-        if *self < *mn { mn.clone() } else { self.clone() }
-    }
-}
-
-
 /* Arithmetic */
 // a/b * c/d = (a*c)/(b*d)
 impl<T: Clone + Integer + Ord>

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

@@ -180,7 +180,6 @@ pub static tag_misc_info: uint = 0x7f;
 pub static tag_misc_info_crate_items: uint = 0x80;
 
 pub static tag_item_method_provided_source: uint = 0x81;
-pub static tag_item_impl_vtables: uint = 0x82;
 
 pub struct LinkMeta {
     name: @str,

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

@@ -16,7 +16,6 @@ use metadata::cstore;
 use metadata::decoder;
 use metadata;
 use middle::ty;
-use middle::typeck;
 
 use std::vec;
 use reader = extra::ebml::reader;
@@ -217,14 +216,6 @@ pub fn get_impl_trait(tcx: ty::ctxt,
     decoder::get_impl_trait(cdata, def.node, tcx)
 }
 
-// Given a def_id for an impl, return information about its vtables
-pub fn get_impl_vtables(tcx: ty::ctxt,
-                        def: ast::def_id) -> typeck::impl_res {
-    let cstore = tcx.cstore;
-    let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_impl_vtables(cdata, def.node, tcx)
-}
-
 pub fn get_impl_method(cstore: @mut cstore::CStore,
                        def: ast::def_id,
                        mname: ast::ident)

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

@@ -21,12 +21,9 @@ use metadata::tydecode::{parse_ty_data, parse_def_id,
                          parse_type_param_def_data,
                          parse_bare_fn_ty_data, parse_trait_ref_data};
 use middle::ty;
-use middle::typeck;
-use middle::astencode::vtable_decoder_helpers;
-
 
 use std::hash::HashUtil;
-use std::uint;
+use std::int;
 use std::io::WriterUtil;
 use std::io;
 use std::option;
@@ -203,9 +200,9 @@ fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool {
     return true;
 }
 
-fn variant_disr_val(d: ebml::Doc) -> Option<uint> {
+fn variant_disr_val(d: ebml::Doc) -> Option<int> {
     do reader::maybe_get_doc(d, tag_disr_val).chain |val_doc| {
-        do reader::with_doc_data(val_doc) |data| { uint::parse_bytes(data, 10u) }
+        do reader::with_doc_data(val_doc) |data| { int::parse_bytes(data, 10u) }
     }
 }
 
@@ -413,21 +410,6 @@ pub fn get_impl_trait(cdata: cmd,
     }
 }
 
-pub fn get_impl_vtables(cdata: cmd,
-                        id: ast::node_id,
-                        tcx: ty::ctxt) -> typeck::impl_res
-{
-    let item_doc = lookup_item(id, cdata.data);
-    let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables);
-    let mut decoder = reader::Decoder(vtables_doc);
-
-    typeck::impl_res {
-        trait_vtables: decoder.read_vtable_res(tcx, cdata),
-        self_vtables: decoder.read_vtable_param_res(tcx, cdata)
-    }
-}
-
-
 pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                        name: ast::ident) -> Option<ast::def_id> {
     let items = reader::get_doc(reader::Doc(cdata.data), tag_items);

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

@@ -17,12 +17,11 @@ use metadata::decoder;
 use metadata::tyencode;
 use middle::ty::{node_id_to_type, lookup_item_type};
 use middle::ty;
-use middle::typeck;
-use middle::astencode;
 use middle;
 
 use std::hash::HashUtil;
 use std::hashmap::{HashMap, HashSet};
+use std::int;
 use std::io;
 use std::str;
 use std::uint;
@@ -163,15 +162,6 @@ fn encode_trait_ref(ebml_w: &mut writer::Encoder,
     ebml_w.end_tag();
 }
 
-fn encode_impl_vtables(ebml_w: &mut writer::Encoder,
-                       ecx: &EncodeContext,
-                       vtables: &typeck::impl_res) {
-    ebml_w.start_tag(tag_item_impl_vtables);
-    astencode::encode_vtable_res(ecx, ebml_w, vtables.trait_vtables);
-    astencode::encode_vtable_param_res(ecx, ebml_w, vtables.self_vtables);
-    ebml_w.end_tag();
-}
-
 // Item info table encoding
 fn encode_family(ebml_w: &mut writer::Encoder, c: char) {
     ebml_w.start_tag(tag_items_data_item_family);
@@ -300,9 +290,9 @@ fn encode_discriminant(ecx: &EncodeContext,
 
 fn encode_disr_val(_: &EncodeContext,
                    ebml_w: &mut writer::Encoder,
-                   disr_val: uint) {
+                   disr_val: int) {
     ebml_w.start_tag(tag_disr_val);
-    let s = uint::to_str(disr_val);
+    let s = int::to_str(disr_val);
     ebml_w.writer.write(s.as_bytes());
     ebml_w.end_tag();
 }
@@ -1019,8 +1009,6 @@ fn encode_info_for_item(ecx: &EncodeContext,
             let trait_ref = ty::node_id_to_trait_ref(
                 tcx, ast_trait_ref.ref_id);
             encode_trait_ref(ebml_w, ecx, trait_ref, tag_item_trait_ref);
-            let impl_vtables = ty::lookup_impl_vtables(tcx, def_id);
-            encode_impl_vtables(ebml_w, ecx, &impl_vtables);
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         ebml_w.end_tag();
@@ -1455,9 +1443,6 @@ fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
     ebml_w.start_tag(tag_lang_items);
 
     for ecx.tcx.lang_items.each_item |def_id, i| {
-        let def_id = match def_id {
-            Some(id) => id, None => { loop }
-        };
         if def_id.crate != local_crate {
             loop;
         }

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

@@ -186,7 +186,7 @@ fn parse_trait_store(st: &mut PState) -> ty::TraitStore {
 }
 
 fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
-    let regions = parse_region_substs(st, |x,y| conv(x,y));
+    let self_r = parse_opt(st, |st| parse_region(st) );
 
     let self_ty = parse_opt(st, |st| parse_ty(st, |x,y| conv(x,y)) );
 
@@ -196,28 +196,12 @@ fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
     st.pos = st.pos + 1u;
 
     return ty::substs {
-        regions: regions,
+        self_r: self_r,
         self_ty: self_ty,
         tps: params
     };
 }
 
-fn parse_region_substs(st: &mut PState, conv: conv_did) -> ty::RegionSubsts {
-    match next(st) {
-        'e' => ty::ErasedRegions,
-        'n' => {
-            let mut regions = opt_vec::Empty;
-            while peek(st) != '.' {
-                let r = parse_region(st);
-                regions.push(r);
-            }
-            assert_eq!(next(st), '.');
-            ty::NonerasedRegions(regions)
-        }
-        _ => fail!("parse_bound_region: bad input")
-    }
-}
-
 fn parse_bound_region(st: &mut PState) -> ty::bound_region {
     match next(st) {
       's' => ty::br_self,

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

@@ -120,28 +120,13 @@ fn enc_opt<T>(w: @io::Writer, t: Option<T>, enc_f: &fn(T)) {
 }
 
 fn enc_substs(w: @io::Writer, cx: @ctxt, substs: &ty::substs) {
-    enc_region_substs(w, cx, &substs.regions);
+    do enc_opt(w, substs.self_r) |r| { enc_region(w, cx, r) }
     do enc_opt(w, substs.self_ty) |t| { enc_ty(w, cx, t) }
     w.write_char('[');
     for substs.tps.iter().advance |t| { enc_ty(w, cx, *t); }
     w.write_char(']');
 }
 
-fn enc_region_substs(w: @io::Writer, cx: @ctxt, substs: &ty::RegionSubsts) {
-    match *substs {
-        ty::ErasedRegions => {
-            w.write_char('e');
-        }
-        ty::NonerasedRegions(ref regions) => {
-            w.write_char('n');
-            for regions.iter().advance |&r| {
-                enc_region(w, cx, r);
-            }
-            w.write_char('.');
-        }
-    }
-}
-
 fn enc_region(w: @io::Writer, cx: @ctxt, r: ty::Region) {
     match r {
       ty::re_bound(br) => {