…rict and weak widening

src/doc/trpl/ffi.md

@@ -120,11 +120,11 @@ pub fn compress(src: &[u8]) -> Vec<u8> {
        let psrc = src.as_ptr();

        let mut dstlen = snappy_max_compressed_length(srclen);
        let mut dst = Vec::with_capacity(dstlen as usize);
        let mut dst = Vec::with_capacity(dstlen);
        let pdst = dst.as_mut_ptr();

        snappy_compress(psrc, srclen, pdst, &mut dstlen);
        dst.set_len(dstlen as usize);
        dst.set_len(dstlen);
        dst
    }
}
@@ -153,11 +153,11 @@ pub fn uncompress(src: &[u8]) -> Option<Vec<u8>> {
        let mut dstlen: size_t = 0;
        snappy_uncompressed_length(psrc, srclen, &mut dstlen);

        let mut dst = Vec::with_capacity(dstlen as usize);
        let mut dst = Vec::with_capacity(dstlen);
        let pdst = dst.as_mut_ptr();

        if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
            dst.set_len(dstlen as usize);
            dst.set_len(dstlen);
            Some(dst)
        } else {
            None // SNAPPY_INVALID_INPUT

src/doc/trpl/lang-items.md

@@ -33,7 +33,7 @@ unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
    let p = libc::malloc(size as libc::size_t) as *mut u8;

    // malloc failed
    if p as usize == 0 {
    if p == 0 {
        abort();
    }

src/doc/trpl/no-stdlib.md

@@ -128,8 +128,8 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
    // cannot tell the pointers are valid.
    let (a_slice, b_slice): (&[u32], &[u32]) = unsafe {
        mem::transmute((
            Slice { data: a, len: a_len as usize },
            Slice { data: b, len: b_len as usize },
            Slice { data: a, len: a_len },
            Slice { data: b, len: b_len },
        ))
    };

src/etc/unicode.py

@@ -406,6 +406,7 @@ def emit_charwidth_module(f, width_table):
    f.write("    use core::option::Option::{Some, None};\n")
    f.write("    use core::slice::SliceExt;\n")
    f.write("    use core::result::Result::{Ok, Err};\n")
    f.write("    use core::num::Widen;\n")
    f.write("""
    fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
        use core::cmp::Ordering::{Equal, Less, Greater};
@@ -430,7 +431,7 @@ def emit_charwidth_module(f, width_table):
            cu if cu < 0x20 => None,    // control sequences have no width
            cu if cu < 0x7F => Some(1), // ASCII
            cu if cu < 0xA0 => None,    // more control sequences
            _ => Some(bsearch_range_value_table(c, is_cjk, charwidth_table) as usize)
            _ => Some(bsearch_range_value_table(c, is_cjk, charwidth_table).widen())
        }
    }

src/grammar/verify.rs

@@ -226,8 +226,8 @@ fn parse_antlr_token(s: &str, tokens: &HashMap<String, token::Token>, surrogate_
    let mut hi = end.parse::<u32>().unwrap() + 1 - offset;

    // Adjust the span: For each surrogate pair already encountered, subtract one position.
    lo -= surrogate_pairs_pos.binary_search(&(lo as usize)).unwrap_or_else(|x| x) as u32;
    hi -= surrogate_pairs_pos.binary_search(&(hi as usize)).unwrap_or_else(|x| x) as u32;
    lo -= surrogate_pairs_pos.binary_search(&(lo)).unwrap_or_else(|x| x) as u32;
    hi -= surrogate_pairs_pos.binary_search(&(hi)).unwrap_or_else(|x| x) as u32;

    let sp = codemap::Span {
        lo: codemap::BytePos(lo),
@@ -274,7 +274,7 @@ fn main() {
    File::open(&Path::new(&filename)).unwrap().read_to_string(&mut code).unwrap();

    let surrogate_pairs_pos: Vec<usize> = code.chars().enumerate()
                                                     .filter(|&(_, c)| c as usize > 0xFFFF)
                                                     .filter(|&(_, c)| c > 0xFFFF)
                                                     .map(|(n, _)| n)
                                                     .enumerate()
                                                     .map(|(x, n)| x + n)

src/liballoc/heap.rs

@@ -9,11 +9,12 @@
// except according to those terms.

use core::{isize, usize};
use core::num::ConvertSign;

#[inline(always)]
fn check_size_and_alignment(size: usize, align: usize) {
    debug_assert!(size != 0);
    debug_assert!(size <= isize::MAX as usize, "Tried to allocate too much: {} bytes", size);
    debug_assert!(size <= isize::MAX.as_unsigned(), "Tried to allocate too much: {} bytes", size);
    debug_assert!(usize::is_power_of_two(align), "Invalid alignment of allocation: {}", align);
}

@@ -204,6 +205,7 @@ mod imp {
    use core::ptr::{null_mut, null};
    use libc::{c_char, c_int, c_void, size_t};
    use super::MIN_ALIGN;
    use core::num::Widen;

    #[link(name = "jemalloc", kind = "static")]
    #[cfg(not(test))]
@@ -254,7 +256,7 @@ mod imp {
    pub unsafe fn reallocate_inplace(ptr: *mut u8, _old_size: usize, size: usize,
                                     align: usize) -> usize {
        let flags = align_to_flags(align);
        je_xallocx(ptr as *mut c_void, size as size_t, 0, flags) as usize
        je_xallocx(ptr as *mut c_void, size as size_t, 0, flags).widen()
    }

    #[inline]
@@ -266,7 +268,7 @@ mod imp {
    #[inline]
    pub fn usable_size(size: usize, align: usize) -> usize {
        let flags = align_to_flags(align);
        unsafe { je_nallocx(size as size_t, flags) as usize }
        unsafe { je_nallocx(size as size_t, flags).widen() }
    }

    pub fn stats_print() {

src/libcollections/bit.rs

@@ -54,7 +54,7 @@
//!     bv.set(0, false);
//!     bv.set(1, false);
//!
//!     for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as usize) {
//!     for i in iter::range_inclusive(2, (max_prime as f64).sqrt()) {
//!         // if i is a prime
//!         if bv[i] {
//!             // Mark all multiples of i as non-prime (any multiples below i * i
@@ -90,6 +90,7 @@ use core::iter::RandomAccessIterator;
use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
use core::iter::{self, FromIterator};
use core::mem::swap;
use core::num::Widen;
use core::ops::Index;
use core::slice;
use core::{u8, u32, usize};
@@ -1876,7 +1877,7 @@ impl BitSet {
    #[inline]
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn len(&self) -> usize  {
        self.bit_vec.blocks().fold(0, |acc, n| acc + n.count_ones() as usize)
        self.bit_vec.blocks().fold(0, |acc, n| acc + n.count_ones().widen_(0usize))
    }

    /// Returns whether there are no bits set in this set
@@ -2048,13 +2049,13 @@ impl<'a, T> Iterator for BlockIter<T> where T: Iterator<Item=u32> {
        // update block, removing the LSB
        self.head &= self.head - 1;
        // return offset + (index of LSB)
        Some(self.head_offset + (u32::count_ones(k) as usize))
        Some(self.head_offset + u32::count_ones(k).widen_(0usize))
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        match self.tail.size_hint() {
            (_, Some(h)) => (0, Some(1 + h * (u32::BITS as usize))),
            (_, Some(h)) => (0, Some(1 + h * (u32::BITS))),
            _ => (0, None)
        }
    }

src/libcollections/enum_set.rs

@@ -18,6 +18,7 @@ use core::marker;
use core::fmt;
use core::iter::{FromIterator};
use core::ops::{Sub, BitOr, BitAnd, BitXor};
use core::num::Widen;

// FIXME(contentions): implement union family of methods? (general design may be wrong here)

@@ -68,7 +69,7 @@ impl<E:CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
///
/// impl CLike for Foo {
///     fn to_usize(&self) -> usize {
///         *self as usize
///         *self
///     }
///
///     fn from_usize(v: usize) -> Foo {
@@ -103,7 +104,7 @@ impl<E:CLike> EnumSet<E> {
    #[unstable(feature = "collections",
               reason = "matches collection reform specification, waiting for dust to settle")]
    pub fn len(&self) -> usize {
        self.bits.count_ones() as usize
        self.bits.count_ones().widen()
    }

    /// Returns true if the `EnumSet` is empty.
@@ -258,7 +259,7 @@ impl<E:CLike> Iterator for Iter<E> {
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let exact = self.bits.count_ones() as usize;
        let exact = self.bits.count_ones().widen();
        (exact, Some(exact))
    }
}

src/libcollections/slice.rs

@@ -91,6 +91,7 @@ use core::iter::Iterator;
use core::marker::Sized;
use core::mem::size_of;
use core::mem;
use core::num::ConvertSign;
use core::ops::FnMut;
use core::option::Option::{self, Some, None};
use core::ptr;
@@ -1259,7 +1260,7 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O
                let tmp = ptr::read(read_ptr);
                ptr::copy(&*buf_v.offset(j),
                          buf_v.offset(j + 1),
                          (i - j) as usize);
                          (i - j).as_unsigned());
                ptr::copy_nonoverlapping(&tmp, buf_v.offset(j), 1);
                mem::forget(tmp);
            }
@@ -1335,7 +1336,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
                // `.offset(j)` is always in bounds.
                ptr::copy(&*buf_dat.offset(j),
                          buf_dat.offset(j + 1),
                          i - j as usize);
                          i - j.as_unsigned());
                ptr::copy_nonoverlapping(read_ptr, buf_dat.offset(j), 1);
            }
        }

src/libcollectionstest/bit/set.rs

@@ -467,7 +467,7 @@ mod bench {
        let mut bit_vec = BitSet::new();
        b.iter(|| {
            for _ in 0..100 {
                bit_vec.insert((r.next_u32() as usize) % u32::BITS);
                bit_vec.insert((r.next_u32().widen_(0usize)) % u32::BITS);
            }
            black_box(&bit_vec);
        });
@@ -479,7 +479,7 @@ mod bench {
        let mut bit_vec = BitSet::new();
        b.iter(|| {
            for _ in 0..100 {
                bit_vec.insert((r.next_u32() as usize) % BENCH_BITS);
                bit_vec.insert((r.next_u32().widen_(0usize)) % BENCH_BITS);
            }
            black_box(&bit_vec);
        });
@@ -492,7 +492,7 @@ mod bench {
        b.iter(|| {
            let mut sum = 0;
            for idx in &bit_vec {
                sum += idx as usize;
                sum += idx;
            }
            sum
        })

src/libcollectionstest/bit/vec.rs

@@ -781,10 +781,10 @@ mod bench {
    #[bench]
    fn bench_usize_small(b: &mut Bencher) {
        let mut r = rng();
        let mut bit_vec = 0 as usize;
        let mut bit_vec = 0;
        b.iter(|| {
            for _ in 0..100 {
                bit_vec |= 1 << ((r.next_u32() as usize) % u32::BITS);
                bit_vec |= 1 << ((r.next_u32().widen_(0usize)) % u32::BITS);
            }
            black_box(&bit_vec);
        });
@@ -796,7 +796,7 @@ mod bench {
        let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
        b.iter(|| {
            for _ in 0..100 {
                bit_vec.set((r.next_u32() as usize) % BENCH_BITS, true);
                bit_vec.set((r.next_u32().widen_(0usize)) % BENCH_BITS, true);
            }
            black_box(&bit_vec);
        });
@@ -808,7 +808,7 @@ mod bench {
        let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
        b.iter(|| {
            for _ in 0..100 {
                bit_vec.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
                bit_vec.set((r.next_u32().widen_(0usize)) % BENCH_BITS, r.gen());
            }
            black_box(&bit_vec);
        });
@@ -820,7 +820,7 @@ mod bench {
        let mut bit_vec = BitVec::from_elem(u32::BITS, false);
        b.iter(|| {
            for _ in 0..100 {
                bit_vec.set((r.next_u32() as usize) % u32::BITS, true);
                bit_vec.set((r.next_u32().widen_(0usize)) % u32::BITS, true);
            }
            black_box(&bit_vec);
        });

src/libcore/atomic.rs

@@ -346,7 +346,7 @@ impl AtomicBool {
    ///
    /// let foo = AtomicBool::new(true);
    /// assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst));
    /// assert_eq!(0, foo.load(Ordering::SeqCst) as usize);
    /// assert_eq!(0, foo.load(Ordering::SeqCst));
    /// assert_eq!(false, foo.load(Ordering::SeqCst));
    ///
    /// let foo = AtomicBool::new(false);

src/libcore/hash/mod.rs

@@ -63,6 +63,7 @@
use prelude::*;

use mem;
use num::ConvertSign;

pub use self::sip::SipHasher;

@@ -160,7 +161,7 @@ pub trait Hasher {
    /// Write a single `isize` into this hasher.
    #[inline]
    #[unstable(feature = "hash", reason = "module was recently redesigned")]
    fn write_isize(&mut self, i: isize) { self.write_usize(i as usize) }
    fn write_isize(&mut self, i: isize) { self.write_usize(i.as_unsigned()) }
}

/// Hash a value with the default SipHasher algorithm (two initial keys of 0).

src/libcore/iter.rs

@@ -65,6 +65,7 @@ use default::Default;
use marker;
use mem;
use num::{Zero, One};
use num::{ConvertSign, Widen};
use ops::{self, Add, Sub, FnMut, Mul, RangeFrom};
use option::Option::{self, Some, None};
use marker::Sized;
@@ -2609,8 +2610,8 @@ macro_rules! step_impl_unsigned {
                if *by == 0 { return None; }
                if *start < *end {
                    // Note: We assume $t <= usize here
                    let diff = (*end - *start) as usize;
                    let by = *by as usize;
                    let diff = (*end - *start).widen_(0usize);
                    let by = by.widen_(0usize);
                    if diff % by > 0 {
                        Some(diff / by + 1)
                    } else {
@@ -2643,14 +2644,14 @@ macro_rules! step_impl_signed {
                    // Note: We assume $t <= isize here
                    // Use .wrapping_sub and cast to usize to compute the
                    // difference that may not fit inside the range of isize.
                    diff = (*end as isize).wrapping_sub(*start as isize) as usize;
                    by_u = *by as usize;
                    diff = (*end as isize).wrapping_sub(*start as isize).as_unsigned();
                    by_u = by.as_unsigned().widen();
                } else {
                    if *start <= *end {
                        return Some(0);
                    }
                    diff = (*start as isize).wrapping_sub(*end as isize) as usize;
                    by_u = (*by as isize).wrapping_mul(-1) as usize;
                    diff = (*start as isize).wrapping_sub(*end as isize).as_unsigned();
                    by_u = (*by as isize).wrapping_mul(-1).as_unsigned();
                }
                if diff % by_u > 0 {
                    Some(diff / by_u + 1)