Use isize/usize in range.

6 files changed, 44 insertions, 45 deletions

diff --git a/components/gfx/paint_context.rs b/components/gfx/paint_context.rs
index 88c031a165f..da15dc6b2ae 100644
--- a/components/gfx/paint_context.rs
+++ b/components/gfx/paint_context.rs
@@ -1199,7 +1199,7 @@ impl ScaledFontExtensionMethods for ScaledFont {
 
         let mut origin = baseline_origin.clone();
         let mut azglyphs = vec!();
-        azglyphs.reserve(range.length().to_uint());
+        azglyphs.reserve(range.length().to_usize());
 
         for slice in run.natural_word_slices_in_range(range) {
             for (_i, glyph) in slice.glyphs.iter_glyphs_for_char_range(&slice.range) {
diff --git a/components/gfx/text/glyph.rs b/components/gfx/text/glyph.rs
index 4ed96281a85..5ebd33916e8 100644
--- a/components/gfx/text/glyph.rs
+++ b/components/gfx/text/glyph.rs
@@ -455,7 +455,7 @@ pub enum GlyphInfo<'a> {
 impl<'a> GlyphInfo<'a> {
     pub fn id(self) -> GlyphId {
         match self {
-            GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_uint()].id(),
+            GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_usize()].id(),
             GlyphInfo::Detail(store, entry_i, detail_j) => {
                 store.detail_store.get_detailed_glyph_with_index(entry_i, detail_j).id
             }
@@ -466,7 +466,7 @@ impl<'a> GlyphInfo<'a> {
     // FIXME: Resolution conflicts with IteratorUtil trait so adding trailing _
     pub fn advance(self) -> Au {
         match self {
-            GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_uint()].advance(),
+            GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_usize()].advance(),
             GlyphInfo::Detail(store, entry_i, detail_j) => {
                 store.detail_store.get_detailed_glyph_with_index(entry_i, detail_j).advance
             }
@@ -575,13 +575,13 @@ impl<'a> GlyphStore {
         };
 
         // FIXME(pcwalton): Is this necessary? I think it's a no-op.
-        entry = entry.adapt_character_flags_of_entry(self.entry_buffer[i.to_uint()]);
+        entry = entry.adapt_character_flags_of_entry(self.entry_buffer[i.to_usize()]);
 
         if character == Some(' ') {
             entry = entry.set_char_is_space()
         }
 
-        self.entry_buffer[i.to_uint()] = entry;
+        self.entry_buffer[i.to_usize()] = entry;
     }
 
     pub fn add_glyphs_for_char_index(&mut self, i: CharIndex, data_for_glyphs: &[GlyphData]) {
@@ -605,11 +605,11 @@ impl<'a> GlyphStore {
                                     first_glyph_data.ligature_start,
                                     glyph_count)
             }
-        }.adapt_character_flags_of_entry(self.entry_buffer[i.to_uint()]);
+        }.adapt_character_flags_of_entry(self.entry_buffer[i.to_usize()]);
 
         debug!("Adding multiple glyphs[idx={:?}, count={}]: {:?}", i, glyph_count, entry);
 
-        self.entry_buffer[i.to_uint()] = entry;
+        self.entry_buffer[i.to_usize()] = entry;
     }
 
     // used when a character index has no associated glyph---for example, a ligature continuation.
@@ -619,7 +619,7 @@ impl<'a> GlyphStore {
         let entry = GlyphEntry::complex(cluster_start, ligature_start, 0);
         debug!("adding spacer for chracter without associated glyph[idx={:?}]", i);
 
-        self.entry_buffer[i.to_uint()] = entry;
+        self.entry_buffer[i.to_usize()] = entry;
     }
 
     pub fn iter_glyphs_for_char_index(&'a self, i: CharIndex) -> GlyphIterator<'a> {
@@ -652,57 +652,57 @@ impl<'a> GlyphStore {
     // getter methods
     pub fn char_is_space(&self, i: CharIndex) -> bool {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].char_is_space()
+        self.entry_buffer[i.to_usize()].char_is_space()
     }
 
     pub fn char_is_tab(&self, i: CharIndex) -> bool {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].char_is_tab()
+        self.entry_buffer[i.to_usize()].char_is_tab()
     }
 
     pub fn char_is_newline(&self, i: CharIndex) -> bool {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].char_is_newline()
+        self.entry_buffer[i.to_usize()].char_is_newline()
     }
 
     pub fn is_ligature_start(&self, i: CharIndex) -> bool {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].is_ligature_start()
+        self.entry_buffer[i.to_usize()].is_ligature_start()
     }
 
     pub fn is_cluster_start(&self, i: CharIndex) -> bool {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].is_cluster_start()
+        self.entry_buffer[i.to_usize()].is_cluster_start()
     }
 
     pub fn can_break_before(&self, i: CharIndex) -> BreakType {
         assert!(i < self.char_len());
-        self.entry_buffer[i.to_uint()].can_break_before()
+        self.entry_buffer[i.to_usize()].can_break_before()
     }
 
     // setter methods
     pub fn set_char_is_space(&mut self, i: CharIndex) {
         assert!(i < self.char_len());
-        let entry = self.entry_buffer[i.to_uint()];
-        self.entry_buffer[i.to_uint()] = entry.set_char_is_space();
+        let entry = self.entry_buffer[i.to_usize()];
+        self.entry_buffer[i.to_usize()] = entry.set_char_is_space();
     }
 
     pub fn set_char_is_tab(&mut self, i: CharIndex) {
         assert!(i < self.char_len());
-        let entry = self.entry_buffer[i.to_uint()];
-        self.entry_buffer[i.to_uint()] = entry.set_char_is_tab();
+        let entry = self.entry_buffer[i.to_usize()];
+        self.entry_buffer[i.to_usize()] = entry.set_char_is_tab();
     }
 
     pub fn set_char_is_newline(&mut self, i: CharIndex) {
         assert!(i < self.char_len());
-        let entry = self.entry_buffer[i.to_uint()];
-        self.entry_buffer[i.to_uint()] = entry.set_char_is_newline();
+        let entry = self.entry_buffer[i.to_usize()];
+        self.entry_buffer[i.to_usize()] = entry.set_char_is_newline();
     }
 
     pub fn set_can_break_before(&mut self, i: CharIndex, t: BreakType) {
         assert!(i < self.char_len());
-        let entry = self.entry_buffer[i.to_uint()];
-        self.entry_buffer[i.to_uint()] = entry.set_can_break_before(t);
+        let entry = self.entry_buffer[i.to_usize()];
+        self.entry_buffer[i.to_usize()] = entry.set_can_break_before(t);
     }
 
     pub fn space_count_in_range(&self, range: &Range<CharIndex>) -> u32 {
@@ -723,7 +723,7 @@ impl<'a> GlyphStore {
         for index in range.each_index() {
             // TODO(pcwalton): Handle spaces that are detailed glyphs -- these are uncommon but
             // possible.
-            let entry = &mut self.entry_buffer[index.to_uint()];
+            let entry = &mut self.entry_buffer[index.to_usize()];
             if entry.is_simple() && entry.char_is_space() {
                 // FIXME(pcwalton): This can overflow for very large font-sizes.
                 let advance =
@@ -789,7 +789,7 @@ impl<'a> Iterator for GlyphIterator<'a> {
             self.char_range.next().and_then(|i| {
                 self.char_index = i;
                 assert!(i < self.store.char_len());
-                let entry = self.store.entry_buffer[i.to_uint()];
+                let entry = self.store.entry_buffer[i.to_usize()];
                 if entry.is_simple() {
                     Some((self.char_index, GlyphInfo::Simple(self.store, i)))
                 } else {
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 1fa36d7beea..0458c2bb738 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -1600,8 +1600,8 @@ impl Fragment {
         // FIXME(pcwalton): Is there a more clever (i.e. faster) way to do this?
         if let Some(ref mut inline_end_range) = inline_end_range {
             let inline_end_fragment_text =
-                text_fragment_info.run.text.slice_chars(inline_end_range.begin().to_uint(),
-                                                        inline_end_range.end().to_uint());
+                text_fragment_info.run.text.slice_chars(inline_end_range.begin().to_usize(),
+                                                        inline_end_range.end().to_usize());
             let mut leading_whitespace_character_count = 0i;
             for ch in inline_end_fragment_text.chars() {
                 if ch.is_whitespace() {
@@ -2128,7 +2128,7 @@ pub enum CoordinateSystem {
 /// if any modifications were made.
 fn strip_trailing_whitespace(text_run: &TextRun, range: &mut Range<CharIndex>) -> bool {
     // FIXME(pcwalton): Is there a more clever (i.e. faster) way to do this?
-    let text = text_run.text.slice_chars(range.begin().to_uint(), range.end().to_uint());
+    let text = text_run.text.slice_chars(range.begin().to_usize(), range.end().to_usize());
     let mut trailing_whitespace_character_count = 0i;
     for ch in text.chars().rev() {
         if ch.is_whitespace() {
diff --git a/components/layout/inline.rs b/components/layout/inline.rs
index 0b645aa0971..5dd4ecf36e3 100644
--- a/components/layout/inline.rs
+++ b/components/layout/inline.rs
@@ -915,7 +915,7 @@ impl InlineFlow {
         }
 
         for fragment_index in range(line.range.begin(), line.range.end()) {
-            let fragment = fragments.get_mut(fragment_index.to_uint());
+            let fragment = fragments.get_mut(fragment_index.to_usize());
             let size = fragment.border_box.size;
             fragment.border_box = LogicalRect::new(fragment.style.writing_mode,
                                                    inline_start_position_for_fragment,
@@ -940,7 +940,7 @@ impl InlineFlow {
         // First, calculate the number of expansion opportunities (spaces, normally).
         let mut expansion_opportunities = 0i32;
         for fragment_index in line.range.each_index() {
-            let fragment = fragments.get(fragment_index.to_uint());
+            let fragment = fragments.get(fragment_index.to_usize());
             let scanned_text_fragment_info =
                 if let SpecificFragmentInfo::ScannedText(ref info) = fragment.specific {
                     info
@@ -957,7 +957,7 @@ impl InlineFlow {
         let space_per_expansion_opportunity = slack_inline_size.to_subpx() /
             (expansion_opportunities as f64);
         for fragment_index in line.range.each_index() {
-            let fragment = fragments.get_mut(fragment_index.to_uint());
+            let fragment = fragments.get_mut(fragment_index.to_usize());
             let mut scanned_text_fragment_info =
                 if let SpecificFragmentInfo::ScannedText(ref mut info) = fragment.specific {
                     info
@@ -1004,7 +1004,7 @@ impl InlineFlow {
                                     baseline_distance_from_block_start: Au,
                                     largest_depth_below_baseline: Au) {
         for fragment_index in range(line.range.begin(), line.range.end()) {
-            let fragment = fragments.get_mut(fragment_index.to_uint());
+            let fragment = fragments.get_mut(fragment_index.to_usize());
             match fragment.vertical_align() {
                 vertical_align::T::top => {
                     fragment.border_box.start.b = fragment.border_box.start.b +
@@ -1221,7 +1221,7 @@ impl Flow for InlineFlow {
                  mut largest_block_size_for_bottom_fragments) = (Au(0), Au(0));
 
             for fragment_index in range(line.range.begin(), line.range.end()) {
-                let fragment = &mut self.fragments.fragments[fragment_index.to_uint()];
+                let fragment = &mut self.fragments.fragments[fragment_index.to_usize()];
 
                 let InlineMetrics {
                     mut block_size_above_baseline,
diff --git a/components/util/lib.rs b/components/util/lib.rs
index 4eaf40b465f..c30e4c714c9 100644
--- a/components/util/lib.rs
+++ b/components/util/lib.rs
@@ -8,7 +8,6 @@
 #![feature(core)]
 #![feature(exit_status)]
 #![feature(hash)]
-#![feature(int_uint)]
 #![feature(io)]
 #![feature(old_io)]
 #![feature(optin_builtin_traits)]
diff --git a/components/util/range.rs b/components/util/range.rs
index 86d670d2f84..0df81a7b413 100644
--- a/components/util/range.rs
+++ b/components/util/range.rs
@@ -16,13 +16,13 @@ pub trait RangeIndex: Int + fmt::Debug {
     fn get(self) -> Self::Index;
 }
 
-impl RangeIndex for int {
-    type Index = int;
+impl RangeIndex for isize {
+    type Index = isize;
     #[inline]
-    fn new(x: int) -> int { x }
+    fn new(x: isize) -> isize { x }
 
     #[inline]
-    fn get(self) -> int { self }
+    fn get(self) -> isize { self }
 }
 
 /// Implements a range index type with operator overloads
@@ -35,8 +35,8 @@ macro_rules! int_range_index {
 
         impl $Self_ {
             #[inline]
-            pub fn to_uint(self) -> uint {
-                self.get() as uint
+            pub fn to_usize(self) -> usize {
+                self.get() as usize
             }
         }
 
@@ -172,16 +172,16 @@ macro_rules! int_range_index {
             }
         }
 
-        impl Shl<uint> for $Self_ {
+        impl Shl<usize> for $Self_ {
             type Output = $Self_;
-            fn shl(self, n: uint) -> $Self_ {
+            fn shl(self, n: usize) -> $Self_ {
                 $Self_(self.get() << n)
             }
         }
 
-        impl Shr<uint> for $Self_ {
+        impl Shr<usize> for $Self_ {
             type Output = $Self_;
-            fn shr(self, n: uint) -> $Self_ {
+            fn shr(self, n: usize) -> $Self_ {
                 $Self_(self.get() >> n)
             }
         }
@@ -247,7 +247,7 @@ impl<T: Int, I: RangeIndex<Index=T>> Iterator for EachIndex<T, I> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         self.it.size_hint()
     }
 }
@@ -399,7 +399,7 @@ impl<T: Int, I: RangeIndex<Index=T>> Range<I> {
     #[inline]
     pub fn is_valid_for_string(&self, s: &str) -> bool {
         let s_len = s.len();
-        match num::cast::<uint, T>(s_len) {
+        match num::cast::<usize, T>(s_len) {
             Some(len) => {
                 let len = RangeIndex::new(len);
                 self.begin() < len