---

yaml
---
r: 40513
b: refs/heads/dist-snap
c: f841d43
h: refs/heads/master
i:
  40511: 9f5d114
v: v3

Author: Dretch

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: 117e5e35831ded02e71554d2e13d6300215119b0
+refs/heads/dist-snap: f841d43f54846111d105dedd046c9646fcce98da
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/io.rs

@@ -404,7 +404,7 @@ fn convert_whence(whence: SeekStyle) -> i32 {
 impl *libc::FILE: Reader {
     fn read(bytes: &[mut u8], len: uint) -> uint {
         do vec::as_mut_buf(bytes) |buf_p, buf_len| {
-            assert buf_len <= len;
+            assert buf_len >= len;
 
             let count = libc::fread(buf_p as *mut c_void, 1u as size_t,
                                     len as size_t, self);
@@ -1208,6 +1208,29 @@ mod tests {
         }
     }
 
+    #[test]
+    #[should_fail]
+    fn test_read_buffer_too_small() {
+        let path = &Path("tmp/lib-io-test-read-buffer-too-small.tmp");
+        // ensure the file exists
+        io::file_writer(path, [io::Create]).get();
+
+        let file = io::file_reader(path).get();
+        let mut buf = vec::from_elem(5, 0);
+        file.read(buf, 6); // this should fail because buf is too small
+    }
+
+    #[test]
+    fn test_read_buffer_big_enough() {
+        let path = &Path("tmp/lib-io-test-read-buffer-big-enough.tmp");
+        // ensure the file exists
+        io::file_writer(path, [io::Create]).get();
+
+        let file = io::file_reader(path).get();
+        let mut buf = vec::from_elem(5, 0);
+        file.read(buf, 4); // this should succeed because buf is big enough
+    }
+
     #[test]
     fn test_write_empty() {
         let file = io::file_writer(&Path("tmp/lib-io-test-write-empty.tmp"),

branches/dist-snap/src/librustc/middle/ty.rs

@@ -41,7 +41,6 @@ export expr_is_lval, expr_kind;
 export ExprKind, LvalueExpr, RvalueDatumExpr, RvalueDpsExpr, RvalueStmtExpr;
 export field_ty;
 export fold_ty, fold_sty_to_ty, fold_region, fold_regions;
-export apply_op_on_t_to_ty_fn;
 export fold_regions_and_ty, walk_regions_and_ty;
 export field;
 export field_idx, field_idx_strict;
@@ -1483,30 +1482,6 @@ fn fold_regions_and_ty(
     }
 }
 
-/* A little utility: it often happens that I have a `fn_ty`,
- * but I want to use some function like `fold_regions_and_ty()`
- * that is defined over all types.  This utility converts to
- * a full type and back.  It's not the best way to do this (somewhat
- * inefficient to do the conversion), it would be better to refactor
- * all this folding business.  However, I've been waiting on that
- * until trait support is improved. */
-fn apply_op_on_t_to_ty_fn(
-    cx: ctxt,
-    f: &FnTy,
-    t_op: fn(t) -> t) -> FnTy
-{
-    let t0 = ty::mk_fn(cx, *f);
-    let t1 = t_op(t0);
-    match ty::get(t1).sty {
-        ty::ty_fn(copy f) => {
-            move f
-        }
-        _ => {
-            cx.sess.bug(~"`t_op` did not return a function type");
-        }
-    }
-}
-
 // n.b. this function is intended to eventually replace fold_region() below,
 // that is why its name is so similar.
 fn fold_regions(

branches/dist-snap/src/librustc/middle/typeck.rs

@@ -251,29 +251,6 @@ fn require_same_types(
     }
 }
 
-// a list of mapping from in-scope-region-names ("isr") to the
-// corresponding ty::Region
-type isr_alist = @List<(ty::bound_region, ty::Region)>;
-
-trait get_and_find_region {
-    fn get(br: ty::bound_region) -> ty::Region;
-    fn find(br: ty::bound_region) -> Option<ty::Region>;
-}
-
-impl isr_alist: get_and_find_region {
-    fn get(br: ty::bound_region) -> ty::Region {
-        self.find(br).get()
-    }
-
-    fn find(br: ty::bound_region) -> Option<ty::Region> {
-        for list::each(self) |isr| {
-            let (isr_br, isr_r) = *isr;
-            if isr_br == br { return Some(isr_r); }
-        }
-        return None;
-    }
-}
-
 fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool {
     match ty::resolved_mode(tcx, a.mode) {
         ast::by_val => { /*ok*/ }

branches/dist-snap/src/librustc/middle/typeck/check.rs

@@ -166,6 +166,29 @@ fn blank_fn_ctxt(ccx: @crate_ctxt, rty: ty::t,
     }
 }
 
+// a list of mapping from in-scope-region-names ("isr") to the
+// corresponding ty::Region
+type isr_alist = @List<(ty::bound_region, ty::Region)>;
+
+trait get_and_find_region {
+    fn get(br: ty::bound_region) -> ty::Region;
+    fn find(br: ty::bound_region) -> Option<ty::Region>;
+}
+
+impl isr_alist: get_and_find_region {
+    fn get(br: ty::bound_region) -> ty::Region {
+        self.find(br).get()
+    }
+
+    fn find(br: ty::bound_region) -> Option<ty::Region> {
+        for list::each(self) |isr| {
+            let (isr_br, isr_r) = *isr;
+            if isr_br == br { return Some(isr_r); }
+        }
+        return None;
+    }
+}
+
 fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
     let visit = visit::mk_simple_visitor(@{
         visit_item: |a| check_item(ccx, a),

branches/dist-snap/src/librustc/middle/typeck/infer.rs

@@ -722,24 +722,5 @@ impl infer_ctxt {
         self.type_error_message(sp, mk_msg, a, Some(err));
     }
 
-    fn replace_bound_regions_with_fresh_regions(
-        &self, span: span,
-        fty: &ty::FnTy) -> (ty::FnTy, isr_alist)
-    {
-        let {fn_ty, isr, _} =
-            replace_bound_regions_in_fn_ty(self.tcx, @Nil, None, fty, |br| {
-                // N.B.: The name of the bound region doesn't have anything to
-                // do with the region variable that's created for it.  The
-                // only thing we're doing with `br` here is using it in the
-                // debug message.
-                let rvar = self.next_region_var_nb(span);
-                debug!("Bound region %s maps to %?",
-                       bound_region_to_str(self.tcx, br),
-                       rvar);
-                rvar
-            });
-        (fn_ty, isr)
-    }
-
 }
 

branches/dist-snap/src/librustc/middle/typeck/infer/combine.rs

@@ -290,9 +290,7 @@ fn super_args<C:combine>(
 
 fn super_vstores<C:combine>(
     self: &C, vk: ty::terr_vstore_kind,
-    a: ty::vstore, b: ty::vstore) -> cres<ty::vstore>
-{
-    debug!("%s.super_vstores(a=%?, b=%?)", self.tag(), a, b);
+    a: ty::vstore, b: ty::vstore) -> cres<ty::vstore> {
 
     match (a, b) {
       (ty::vstore_slice(a_r), ty::vstore_slice(b_r)) => {
@@ -519,3 +517,4 @@ fn super_tys<C:combine>(
       _ => Err(ty::terr_sorts(expected_found(self, a, b)))
     }
 }
+

branches/dist-snap/src/librustc/middle/typeck/infer/lub.rs

@@ -3,8 +3,6 @@ use lattice::*;
 use to_str::ToStr;
 use syntax::ast::{Many, Once};
 
-fn macros() { include!("macros.rs"); } // FIXME(#3114): Macro import/export.
-
 enum Lub = combine_fields;  // "subtype", "subregion" etc
 
 impl Lub: combine {
@@ -104,100 +102,6 @@ impl Lub: combine {
         }
     }
 
-    fn fns(a: &ty::FnTy, b: &ty::FnTy) -> cres<ty::FnTy> {
-        // Note: this is a subtle algorithm.  For a full explanation,
-        // please see the large comment in `region_inference.rs`.
-
-        // Take a snapshot.  We'll never roll this back, but in later
-        // phases we do want to be able to examine "all bindings that
-        // were created as part of this type comparison", and making a
-        // snapshot is a convenient way to do that.
-        let snapshot = self.infcx.region_vars.start_snapshot();
-
-        // Instantiate each bound region with a fresh region variable.
-        let (a_with_fresh, a_isr) =
-            self.infcx.replace_bound_regions_with_fresh_regions(
-                self.span, a);
-        let (b_with_fresh, _) =
-            self.infcx.replace_bound_regions_with_fresh_regions(
-                self.span, b);
-
-        // Collect constraints.
-        let fn_ty0 = if_ok!(super_fns(&self, &a_with_fresh, &b_with_fresh));
-        debug!("fn_ty0 = %s", fn_ty0.to_str(self.infcx));
-
-        // Generalize the regions appearing in fn_ty0 if possible
-        let new_vars =
-            self.infcx.region_vars.vars_created_since_snapshot(snapshot);
-        let fn_ty1 =
-            ty::apply_op_on_t_to_ty_fn(
-                self.infcx.tcx, &fn_ty0,
-                |t| ty::fold_regions(
-                    self.infcx.tcx, t,
-                    |r, _in_fn| generalize_region(&self, snapshot,
-                                                  new_vars, a_isr, r)));
-        return Ok(move fn_ty1);
-
-        fn generalize_region(self: &Lub,
-                             snapshot: uint,
-                             new_vars: &[RegionVid],
-                             a_isr: isr_alist,
-                             r0: ty::Region) -> ty::Region {
-            // Regions that pre-dated the LUB computation stay as they are.
-            if !is_new_var(new_vars, r0) {
-                debug!("generalize_region(r0=%?): not new variable", r0);
-                return r0;
-            }
-
-            let tainted = self.infcx.region_vars.tainted(snapshot, r0);
-
-            // Variables created during LUB computation which are
-            // *related* to regions that pre-date the LUB computation
-            // stay as they are.
-            if !tainted.all(|r| is_new_var(new_vars, *r)) {
-                debug!("generalize_region(r0=%?): \
-                        non-new-variables found in %?",
-                       r0, tainted);
-                return r0;
-            }
-
-            // Otherwise, the variable must be associated with at
-            // least one of the variables representing bound regions
-            // in both A and B.  Replace the variable with the "first"
-            // bound region from A that we find it to be associated
-            // with.
-            for list::each(a_isr) |pair| {
-                let (a_br, a_r) = *pair;
-                if tainted.contains(&a_r) {
-                    debug!("generalize_region(r0=%?): \
-                            replacing with %?, tainted=%?",
-                           r0, a_br, tainted);
-                    return ty::re_bound(a_br);
-                }
-            }
-
-            self.infcx.tcx.sess.span_bug(
-                self.span,
-                fmt!("Region %? is not associated with \
-                      any bound region from A!", r0));
-        }
-
-        fn is_new_var(new_vars: &[RegionVid], r: ty::Region) -> bool {
-            match r {
-                ty::re_infer(ty::ReVar(ref v)) => new_vars.contains(v),
-                _ => false
-            }
-        }
-    }
-
-    fn fn_metas(a: &ty::FnMeta, b: &ty::FnMeta) -> cres<ty::FnMeta> {
-        super_fn_metas(&self, a, b)
-    }
-
-    fn fn_sigs(a: &ty::FnSig, b: &ty::FnSig) -> cres<ty::FnSig> {
-        super_fn_sigs(&self, a, b)
-    }
-
     // Traits please (FIXME: #2794):
 
     fn tys(a: ty::t, b: ty::t) -> cres<ty::t> {
@@ -221,6 +125,18 @@ impl Lub: combine {
         super_args(&self, a, b)
     }
 
+    fn fns(a: &ty::FnTy, b: &ty::FnTy) -> cres<ty::FnTy> {
+        super_fns(&self, a, b)
+    }
+
+    fn fn_metas(a: &ty::FnMeta, b: &ty::FnMeta) -> cres<ty::FnMeta> {
+        super_fn_metas(&self, a, b)
+    }
+
+    fn fn_sigs(a: &ty::FnSig, b: &ty::FnSig) -> cres<ty::FnSig> {
+        super_fn_sigs(&self, a, b)
+    }
+
     fn substs(did: ast::def_id,
               as_: &ty::substs,
               bs: &ty::substs) -> cres<ty::substs> {