---

yaml
---
r: 55993
b: refs/heads/auto
c: 9963bd2
h: refs/heads/master
i:
  55991: 085407e
v: v3

Author: nikomatsakis

[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: 412a07055c211f2dec4fb87f25b87d2d71fb13de
+refs/heads/auto: 9963bd24138999e745584a138f8381f91e3a308c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/num/int-template.rs

@@ -107,15 +107,11 @@ pub fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) {
     } else if step > 0 { // ascending
         while i < stop {
             if !it(i) { break }
-            // avoiding overflow. break if i + step > max_value
-            if i > max_value - step { break; }
             i += step;
         }
     } else { // descending
         while i > stop {
             if !it(i) { break }
-            // avoiding underflow. break if i + step < min_value
-            if i < min_value - step { break; }
             i += step;
         }
     }
@@ -425,26 +421,10 @@ pub fn test_ranges() {
     for range_step(36,30,-2) |i| {
         l.push(i);
     }
-    for range_step(max_value - 2, max_value, 2) |i| {
-        l.push(i);
-    }
-    for range_step(max_value - 3, max_value, 2) |i| {
-        l.push(i);
-    }
-    for range_step(min_value + 2, min_value, -2) |i| {
-        l.push(i);
-    }
-    for range_step(min_value + 3, min_value, -2) |i| {
-        l.push(i);
-    }
-    assert_eq!(l, ~[0,1,2,
-                    13,12,11,
-                    20,22,24,
-                    36,34,32,
-                    max_value-2,
-                    max_value-3,max_value-1,
-                    min_value+2,
-                    min_value+3,min_value+1]);
+    assert!(l == ~[0,1,2,
+                        13,12,11,
+                        20,22,24,
+                        36,34,32]);
 
     // None of the `fail`s should execute.
     for range(10,0) |_i| {

branches/auto/src/libcore/num/uint-template.rs

@@ -78,15 +78,12 @@ pub fn range_step(start: T,
     if step >= 0 {
         while i < stop {
             if !it(i) { break }
-            // avoiding overflow. break if i + step > max_value
-            if i > max_value - (step as T) { break; }
             i += step as T;
         }
-    } else {
+    }
+    else {
         while i > stop {
             if !it(i) { break }
-            // avoiding underflow. break if i + step < min_value
-            if i < min_value + ((-step) as T) { break; }
             i -= -step as T;
         }
     }
@@ -374,27 +371,11 @@ pub fn test_ranges() {
     for range_step(36,30,-2) |i| {
         l.push(i);
     }
-    for range_step(max_value - 2, max_value, 2) |i| {
-        l.push(i);
-    }
-    for range_step(max_value - 3, max_value, 2) |i| {
-        l.push(i);
-    }
-    for range_step(min_value + 2, min_value, -2) |i| {
-        l.push(i);
-    }
-    for range_step(min_value + 3, min_value, -2) |i| {
-        l.push(i);
-    }
 
-    assert_eq!(l, ~[0,1,2,
-                    13,12,11,
-                    20,22,24,
-                    36,34,32,
-                    max_value-2,
-                    max_value-3,max_value-1,
-                    min_value+2,
-                    min_value+3,min_value+1]);
+    assert!(l == ~[0,1,2,
+                        13,12,11,
+                        20,22,24,
+                        36,34,32]);
 
     // None of the `fail`s should execute.
     for range(0,0) |_i| {

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

@@ -127,7 +127,7 @@ pub enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_node_type_subst = 0x58,
     tag_table_freevars = 0x59,
     tag_table_tcache = 0x5a,
-    tag_table_param_bounds = 0x5b,
+    tag_table_param_defs = 0x5b,
     tag_table_inferred_modes = 0x5c,
     tag_table_mutbl = 0x5d,
     tag_table_last_use = 0x5e,

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

@@ -210,7 +210,7 @@ pub fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
     debug!("got field data %?", the_field);
     let ty = decoder::item_type(def, the_field, tcx, cdata);
     ty::ty_param_bounds_and_ty {
-        generics: ty::Generics {bounds: @~[],
+        generics: ty::Generics {type_param_defs: @~[],
                                 region_param: None},
         ty: ty
     }

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

@@ -19,7 +19,8 @@ use metadata::csearch::{ProvidedTraitMethodInfo, StaticMethodInfo};
 use metadata::csearch;
 use metadata::cstore;
 use metadata::decoder;
-use metadata::tydecode::{parse_ty_data, parse_def_id, parse_bounds_data,
+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, resolve};
 
@@ -266,13 +267,14 @@ fn item_trait_ref(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::TraitRef {
     doc_trait_ref(tp, tcx, cdata)
 }
 
-fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
-                        tag: uint)
-    -> @~[ty::param_bounds] {
+fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
+                      tag: uint)
+    -> @~[ty::TypeParameterDef] {
     let mut bounds = ~[];
     for reader::tagged_docs(item, tag) |p| {
-        let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx,
-                                   |_, did| translate_def_id(cdata, did));
+        let bd = parse_type_param_def_data(
+            p.data, p.start, cdata.cnum, tcx,
+            |_, did| translate_def_id(cdata, did));
         bounds.push(bd);
     }
     @bounds
@@ -378,11 +380,11 @@ pub fn get_trait_def(cdata: cmd,
                      tcx: ty::ctxt) -> ty::TraitDef
 {
     let item_doc = lookup_item(item_id, cdata.data);
-    let tp_bounds = item_ty_param_bounds(item_doc, tcx, cdata,
-                                         tag_items_data_item_ty_param_bounds);
+    let tp_defs = item_ty_param_defs(item_doc, tcx, cdata,
+                                     tag_items_data_item_ty_param_bounds);
     let rp = item_ty_region_param(item_doc);
     ty::TraitDef {
-        generics: ty::Generics {bounds: tp_bounds,
+        generics: ty::Generics {type_param_defs: tp_defs,
                                 region_param: rp},
         trait_ref: @item_trait_ref(item_doc, tcx, cdata)
     }
@@ -394,12 +396,12 @@ pub fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     let item = lookup_item(id, cdata.data);
     let t = item_type(ast::def_id { crate: cdata.cnum, node: id }, item, tcx,
                       cdata);
-    let tp_bounds = if family_has_type_params(item_family(item)) {
-        item_ty_param_bounds(item, tcx, cdata, tag_items_data_item_ty_param_bounds)
+    let tp_defs = if family_has_type_params(item_family(item)) {
+        item_ty_param_defs(item, tcx, cdata, tag_items_data_item_ty_param_bounds)
     } else { @~[] };
     let rp = item_ty_region_param(item);
     ty::ty_param_bounds_and_ty {
-        generics: ty::Generics {bounds: tp_bounds,
+        generics: ty::Generics {type_param_defs: tp_defs,
                                 region_param: rp},
         ty: t
     }
@@ -753,17 +755,16 @@ pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let method_doc = lookup_item(id, cdata.data);
     let def_id = item_def_id(method_doc, cdata);
     let name = item_name(intr, method_doc);
-    let bounds =
-        item_ty_param_bounds(method_doc, tcx, cdata,
-                             tag_item_method_tps);
+    let type_param_defs = item_ty_param_defs(method_doc, tcx, cdata,
+                                             tag_item_method_tps);
     let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata);
     let fty = doc_method_fty(method_doc, tcx, cdata);
     let vis = item_visibility(method_doc);
     let self_ty = get_self_ty(method_doc);
     ty::method {
         ident: name,
         generics: ty::Generics {
-            bounds: bounds,
+            type_param_defs: type_param_defs,
             region_param: None
         },
         transformed_self_ty: transformed_self_ty,
@@ -797,8 +798,9 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
 
         let did = item_def_id(mth, cdata);
 
-        let bounds = item_ty_param_bounds(mth, tcx, cdata,
-                                          tag_items_data_item_ty_param_bounds);
+        let type_param_defs =
+            item_ty_param_defs(mth, tcx, cdata,
+                               tag_items_data_item_ty_param_bounds);
         let name = item_name(intr, mth);
         let ty = doc_type(mth, tcx, cdata);
 
@@ -815,7 +817,7 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
         let ty_method = ty::method {
             ident: name,
             generics: ty::Generics {
-                bounds: bounds,
+                type_param_defs: type_param_defs,
                 region_param: None
             },
             transformed_self_ty: transformed_self_ty,

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

@@ -179,10 +179,10 @@ fn encode_family(ebml_w: writer::Encoder, c: char) {
 
 pub fn def_to_str(did: def_id) -> ~str { fmt!("%d:%d", did.crate, did.node) }
 
-fn encode_ty_type_param_bounds(ebml_w: writer::Encoder,
-                               ecx: @EncodeContext,
-                               params: @~[ty::param_bounds],
-                               tag: uint) {
+fn encode_ty_type_param_defs(ebml_w: writer::Encoder,
+                             ecx: @EncodeContext,
+                             params: @~[ty::TypeParameterDef],
+                             tag: uint) {
     let ty_str_ctxt = @tyencode::ctxt {
         diag: ecx.diag,
         ds: def_to_str,
@@ -191,18 +191,18 @@ fn encode_ty_type_param_bounds(ebml_w: writer::Encoder,
         abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     for params.each |param| {
         ebml_w.start_tag(tag);
-        tyencode::enc_bounds(ebml_w.writer, ty_str_ctxt, *param);
+        tyencode::enc_type_param_def(ebml_w.writer, ty_str_ctxt, param);
         ebml_w.end_tag();
     }
 }
 
 fn encode_type_param_bounds(ebml_w: writer::Encoder,
                             ecx: @EncodeContext,
                             params: &OptVec<TyParam>) {
-    let ty_param_bounds =
-        @params.map_to_vec(|param| *ecx.tcx.ty_param_bounds.get(&param.id));
-    encode_ty_type_param_bounds(ebml_w, ecx, ty_param_bounds,
-                                tag_items_data_item_ty_param_bounds);
+    let ty_param_defs =
+        @params.map_to_vec(|param| *ecx.tcx.ty_param_defs.get(&param.id));
+    encode_ty_type_param_defs(ebml_w, ecx, ty_param_defs,
+                              tag_items_data_item_ty_param_bounds);
 }
 
 
@@ -588,8 +588,9 @@ fn encode_method_ty_fields(ecx: @EncodeContext,
 {
     encode_def_id(ebml_w, method_ty.def_id);
     encode_name(ecx, ebml_w, method_ty.ident);
-    encode_ty_type_param_bounds(ebml_w, ecx, method_ty.generics.bounds,
-                                tag_item_method_tps);
+    encode_ty_type_param_defs(ebml_w, ecx,
+                              method_ty.generics.type_param_defs,
+                              tag_item_method_tps);
     encode_transformed_self_ty(ecx, ebml_w, method_ty.transformed_self_ty);
     encode_method_fty(ecx, ebml_w, &method_ty.fty);
     encode_visibility(ebml_w, method_ty.vis);
@@ -952,8 +953,9 @@ fn encode_info_for_item(ecx: @EncodeContext, ebml_w: writer::Encoder,
                                       method_ty.fty.purity));
 
                     let tpt = ty::lookup_item_type(tcx, method_def_id);
-                    encode_ty_type_param_bounds(ebml_w, ecx, tpt.generics.bounds,
-                                                tag_items_data_item_ty_param_bounds);
+                    encode_ty_type_param_defs(ebml_w, ecx,
+                                              tpt.generics.type_param_defs,
+                                              tag_items_data_item_ty_param_bounds);
                     encode_type(ecx, ebml_w, tpt.ty);
                 }
 

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

@@ -547,11 +547,17 @@ pub fn parse_def_id(buf: &[u8]) -> ast::def_id {
     ast::def_id { crate: crate_num, node: def_num }
 }
 
-pub fn parse_bounds_data(data: @~[u8], start: uint,
-                         crate_num: int, tcx: ty::ctxt, conv: conv_did)
-                      -> @~[ty::param_bound] {
+pub fn parse_type_param_def_data(data: @~[u8], start: uint,
+                                 crate_num: int, tcx: ty::ctxt,
+                                 conv: conv_did) -> ty::TypeParameterDef
+{
     let st = parse_state_from_data(data, crate_num, start, tcx);
-    parse_bounds(st, conv)
+    parse_type_param_def(st, conv)
+}
+
+fn parse_type_param_def(st: @mut PState, conv: conv_did) -> ty::TypeParameterDef {
+    ty::TypeParameterDef {def_id: parse_def(st, NominalType, conv),
+                          bounds: parse_bounds(st, conv)}
 }
 
 fn parse_bounds(st: @mut PState, conv: conv_did) -> @~[ty::param_bound] {

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

@@ -412,7 +412,7 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     enc_ty(w, cx, fsig.output);
 }
 
-pub fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) {
+fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) {
     for vec::each(*bs) |bound| {
         match *bound {
           ty::bound_owned => w.write_char('S'),
@@ -428,6 +428,12 @@ pub fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) {
     w.write_char('.');
 }
 
+pub fn enc_type_param_def(w: @io::Writer, cx: @ctxt, v: &ty::TypeParameterDef) {
+    w.write_str((cx.ds)(v.def_id));
+    w.write_char('|');
+    enc_bounds(w, cx, v.bounds);
+}
+
 //
 // Local Variables:
 // mode: rust