Rust upgrade to rustc hash b03a2755193cd756583bcf5831cf4545d75ecb8a

components/util/bloom.rs

@@ -6,10 +6,10 @@
 
 use string_cache::{Atom, Namespace};
 
-static KEY_SIZE: uint = 12;
-static ARRAY_SIZE: uint = 1 << KEY_SIZE;
-static KEY_MASK: u32 = (1 << KEY_SIZE) - 1;
-static KEY_SHIFT: uint = 16;
+const KEY_SIZE: uint = 12;
+const ARRAY_SIZE: uint = 1 << KEY_SIZE;
+const KEY_MASK: u32 = (1 << KEY_SIZE) - 1;
+const KEY_SHIFT: uint = 16;
 
 /// A counting Bloom filter with 8-bit counters.  For now we assume
 /// that having two hash functions is enough, but we may revisit that
@@ -334,4 +334,3 @@ mod bench {
         })
     }
 }
-

components/util/cache.rs

@@ -2,7 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::collections::hashmap::HashMap;
+use std::collections::HashMap;
+use std::collections::hash_map::{Occupied, Vacant};
 use rand::Rng;
 use std::hash::{Hash, sip};
 use std::rand::task_rng;
@@ -36,14 +37,21 @@ impl<K: Clone + PartialEq + Eq + Hash, V: Clone> Cache<K,V> for HashCache<K,V> {
     }
 
     fn find(&mut self, key: &K) -> Option<V> {
-        match self.entries.find(key) {
+        match self.entries.get(key) {
             Some(v) => Some(v.clone()),
             None    => None,
         }
     }
 
     fn find_or_create(&mut self, key: &K, blk: |&K| -> V) -> V {
-        self.entries.find_or_insert_with(key.clone(), blk).clone()
+        match self.entries.entry(key.clone()) {
+            Occupied(occupied) => {
+                (*occupied.get()).clone()
+            }
+            Vacant(vacant) => {
+                (*vacant.set(blk(key))).clone()
+            }
+        }
     }
 
     fn evict_all(&mut self) {
@@ -53,7 +61,7 @@ impl<K: Clone + PartialEq + Eq + Hash, V: Clone> Cache<K,V> for HashCache<K,V> {
 }
 
 impl<K,V> HashCache<K,V> where K: Clone + PartialEq + Eq + Hash, V: Clone {
-    pub fn find_equiv<'a,Q>(&'a self, key: &Q) -> Option<&'a V> where Q: Hash + Equiv<K> {
+    pub fn find_equiv<'a,Sized? Q>(&'a self, key: &Q) -> Option<&'a V> where Q: Hash + Equiv<K> {
         self.entries.find_equiv(key)
     }
 }
@@ -171,7 +179,7 @@ impl<K:Clone+PartialEq+Hash,V:Clone> SimpleHashCache<K,V> {
 impl<K:Clone+PartialEq+Hash,V:Clone> Cache<K,V> for SimpleHashCache<K,V> {
     fn insert(&mut self, key: K, value: V) {
         let bucket_index = self.bucket_for_key(&key);
-        *self.entries.get_mut(bucket_index) = Some((key, value));
+        self.entries[bucket_index] = Some((key, value));
     }
 
     fn find(&mut self, key: &K) -> Option<V> {

components/util/dlist.rs

@@ -24,7 +24,7 @@ struct RawNode<T> {
 #[unsafe_destructor]
 impl<T> Drop for RawDList<T> {
     fn drop(&mut self) {
-        fail!("shouldn't happen")
+        panic!("shouldn't happen")
     }
 }
 
@@ -36,7 +36,7 @@ pub fn split<T>(list: &mut DList<T>) -> DList<T> {
     };
 
     if list.length == 0 {
-        fail!("split_dlist(): empty list")
+        panic!("split_dlist(): empty list")
     }
     let head_node = mem::replace(&mut list.head, ptr::null_mut());
     let head_list = RawDList {
@@ -96,4 +96,3 @@ pub fn append_from<T>(this: &mut DList<T>, other: &mut DList<T>) {
         other.length = 0;
     }
 }
-

components/util/fnv.rs

@@ -19,7 +19,7 @@ pub struct FnvHasher;
 pub struct FnvState(u64);
 
 impl Hasher<FnvState> for FnvHasher {
-    fn hash<T: Hash<FnvState>>(&self, t: &T) -> u64 {
+    fn hash<Sized? T: Hash<FnvState>>(&self, t: &T) -> u64 {
         let mut state = FnvState(0xcbf29ce484222325);
         t.hash(&mut state);
         let FnvState(ret) = state;

components/util/geometry.rs

@@ -28,6 +28,7 @@ use std::fmt;
 ///
 /// The ratio between ScreenPx and DevicePixel for a given display be found by calling
 /// `servo::windowing::WindowMethods::hidpi_factor`.
+#[deriving(Show)]
 pub enum ScreenPx {}
 
 /// One CSS "px" in the coordinate system of the "initial viewport":
@@ -39,7 +40,7 @@ pub enum ScreenPx {}
 ///
 /// At the default zoom level of 100%, one PagePx is equal to one ScreenPx.  However, if the
 /// document is zoomed in or out then this scale may be larger or smaller.
-#[deriving(Encodable)]
+#[deriving(Encodable, Show)]
 pub enum ViewportPx {}
 
 /// One CSS "px" in the root coordinate system for the content document.
@@ -48,7 +49,7 @@ pub enum ViewportPx {}
 /// This is the mobile-style "pinch zoom" that enlarges content without reflowing it.  When the
 /// viewport zoom is not equal to 1.0, then the layout viewport is no longer the same physical size
 /// as the viewable area.
-#[deriving(Encodable)]
+#[deriving(Encodable, Show)]
 pub enum PagePx {}
 
 // In summary, the hierarchy of pixel units and the factors to convert from one to the next:
@@ -95,8 +96,8 @@ pub static MAX_RECT: Rect<Au> = Rect {
     }
 };
 
-pub static MIN_AU: Au = Au(i32::MIN);
-pub static MAX_AU: Au = Au(i32::MAX);
+pub const MIN_AU: Au = Au(i32::MIN);
+pub const MAX_AU: Au = Au(i32::MAX);
 
 impl<E, S: Encoder<E>> Encodable<S, E> for Au {
     fn encode(&self, e: &mut S) -> Result<(), E> {
@@ -319,4 +320,3 @@ pub fn f32_rect_to_au_rect(rect: Rect<f32>) -> Rect<Au> {
     Rect(Point2D(Au::from_frac32_px(rect.origin.x), Au::from_frac32_px(rect.origin.y)),
          Size2D(Au::from_frac32_px(rect.size.width), Au::from_frac32_px(rect.size.height)))
 }
-

components/util/lib.rs

@@ -4,13 +4,13 @@
 
 #![feature(default_type_params,macro_rules,unsafe_destructor)]
 
-#![deny(unused_imports, unused_variable)]
+#![deny(unused_imports)]
+#![deny(unused_variables)]
 
 #![feature(phase)]
 #[phase(plugin, link)]
 extern crate log;
 
-extern crate debug;
 extern crate alloc;
 extern crate collections;
 extern crate geom;

components/util/logical_geometry.rs

@@ -12,39 +12,39 @@ use std::num::Zero;
 bitflags!(
     #[deriving(Encodable)]
     flags WritingMode: u8 {
-        static FlagRTL = 1 << 0,
-        static FlagVertical = 1 << 1,
-        static FlagVerticalLR = 1 << 2,
-        static FlagSidewaysLeft = 1 << 3
+        const FLAG_RTL = 1 << 0,
+        const FLAG_VERTICAL = 1 << 1,
+        const FLAG_VERTICAL_LR = 1 << 2,
+        const FLAG_SIDEWAYS_LEFT = 1 << 3
     }
 )
 
 impl WritingMode {
     #[inline]
     pub fn is_vertical(&self) -> bool {
-        self.intersects(FlagVertical)
+        self.intersects(FLAG_VERTICAL)
     }
 
     /// Asuming .is_vertical(), does the block direction go left to right?
     #[inline]
     pub fn is_vertical_lr(&self) -> bool {
-        self.intersects(FlagVerticalLR)
+        self.intersects(FLAG_VERTICAL_LR)
     }
 
     /// Asuming .is_vertical(), does the inline direction go top to bottom?
     #[inline]
     pub fn is_inline_tb(&self) -> bool {
-        !(self.intersects(FlagSidewaysLeft) ^ self.intersects(FlagRTL))
+        !(self.intersects(FLAG_SIDEWAYS_LEFT) ^ self.intersects(FLAG_RTL))
     }
 
     #[inline]
     pub fn is_bidi_ltr(&self) -> bool {
-        !self.intersects(FlagRTL)
+        !self.intersects(FLAG_RTL)
     }
 
     #[inline]
     pub fn is_sideways_left(&self) -> bool {
-        self.intersects(FlagSidewaysLeft)
+        self.intersects(FLAG_SIDEWAYS_LEFT)
     }
 }
 
@@ -57,7 +57,7 @@ impl Show for WritingMode {
             } else {
                 try!(write!(formatter, " RL"));
             }
-            if self.intersects(FlagSidewaysLeft) {
+            if self.intersects(FLAG_SIDEWAYS_LEFT) {
                 try!(write!(formatter, " SidewaysL"));
             }
         } else {

components/util/memory.rs

@@ -198,13 +198,12 @@ fn get_resident() -> Option<u64> {
     resident_size()
 }
 
-#[cfg(not(target_os="linux"), not(target_os = "macos"))]
+#[cfg(not(any(target_os="linux", target_os = "macos")))]
 fn get_vsize() -> Option<u64> {
     None
 }
 
-#[cfg(not(target_os="linux"), not(target_os = "macos"))]
+#[cfg(not(any(target_os="linux", target_os = "macos")))]
 fn get_resident() -> Option<u64> {
     None
 }
-

components/util/rtinstrument.rs

@@ -161,6 +161,10 @@ impl InstrumentedRuntime {
 }
 
 impl Runtime for InstrumentedRuntime {
+    fn stack_guard(&self) -> Option<uint> {
+        self.inner.as_ref().unwrap().stack_guard()
+    }
+
     fn yield_now(mut self: Box<InstrumentedRuntime>, cur_task: Box<Task>) {
         self.inner.take().unwrap().yield_now(cur_task);
         self.put(None)

components/util/smallvec.rs

@@ -5,7 +5,7 @@
 //! Small vectors in various sizes. These store a certain number of elements inline and fall back
 //! to the heap for larger allocations.
 
-use std::mem::init as i;
+use std::mem::zeroed as i;
 use std::cmp;
 use std::fmt;
 use std::intrinsics;
@@ -153,7 +153,7 @@ pub trait SmallVec<T> : SmallVecPrivate<T> {
             let last_index = self.len() - 1;
 
             if (last_index as int) < 0 {
-                fail!("overflow")
+                panic!("overflow")
             }
             let end_ptr = self.begin().offset(last_index as int);
 
@@ -239,7 +239,7 @@ pub trait SmallVec<T> : SmallVecPrivate<T> {
     }
 
     fn fail_bounds_check(&self, index: uint) {
-        fail!("index {} beyond length ({})", index, self.len())
+        panic!("index {} beyond length ({})", index, self.len())
     }
 }
 

components/util/str.rs

@@ -71,7 +71,7 @@ pub fn split_html_space_chars<'a>(s: &'a str) -> Filter<'a, &'a str, CharSplits<
 fn do_parse_integer<T: Iterator<char>>(input: T) -> Option<i64> {
     fn is_ascii_digit(c: &char) -> bool {
         match *c {
-            '0'..'9' => true,
+            '0'...'9' => true,
             _ => false,
         }
     }
@@ -152,7 +152,7 @@ pub fn parse_length(mut value: &str) -> LengthOrPercentageOrAuto {
     let (mut found_full_stop, mut found_percent) = (false, false);
     for (i, ch) in value.chars().enumerate() {
         match ch {
-            '0'..'9' => continue,
+            '0'...'9' => continue,
             '%' => {
                 found_percent = true;
                 end_index = i;

components/util/task_state.rs

@@ -13,13 +13,13 @@ pub use self::imp::{initialize, get, enter, exit};
 bitflags! {
     #[deriving(Show)]
     flags TaskState: u32 {
-        static Script        = 0x01,
-        static Layout        = 0x02,
-        static Render        = 0x04,
+        const SCRIPT          = 0x01,
+        const LAYOUT          = 0x02,
+        const RENDER          = 0x04,
 
-        static InWorker      = 0x0100,
-        static InGC          = 0x0200,
-        static InHTMLParser  = 0x0400,
+        const IN_WORKER       = 0x0100,
+        const IN_GC           = 0x0200,
+        const IN_HTML_PARSER  = 0x0400,
     }
 }
 
@@ -38,9 +38,9 @@ macro_rules! task_types ( ( $( $fun:ident = $flag:ident ; )* ) => (
 ))
 
 task_types! {
-    is_script = Script;
-    is_layout = Layout;
-    is_render = Render;
+    is_script = SCRIPT;
+    is_layout = LAYOUT;
+    is_render = RENDER;
 }
 
 #[cfg(not(ndebug))]
@@ -52,14 +52,14 @@ mod imp {
     pub fn initialize(x: TaskState) {
         match STATE.replace(Some(x)) {
             None => (),
-            Some(s) => fail!("Task state already initialized as {}", s),
+            Some(s) => panic!("Task state already initialized as {}", s),
         };
         get(); // check the assertion below
     }
 
     pub fn get() -> TaskState {
         let state = match STATE.get() {
-            None => fail!("Task state not initialized"),
+            None => panic!("Task state not initialized"),
             Some(s) => *s,
         };
 

components/util/tid.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, SeqCst};
+use std::sync::atomic::{AtomicUint, INIT_ATOMIC_UINT, SeqCst};
 
 static mut next_tid: AtomicUint = INIT_ATOMIC_UINT;
 

components/util/time.rs

@@ -4,7 +4,7 @@
 
 //! Timing functions.
 
-use collections::treemap::TreeMap;
+use collections::TreeMap;
 use std::comm::{Sender, channel, Receiver};
 use std::f64;
 use std::io::timer::sleep;
@@ -196,7 +196,7 @@ impl TimeProfiler {
     }
 
     fn find_or_insert(&mut self, k: (TimeProfilerCategory, Option<TimerMetadata>), t: f64) {
-        match self.buckets.find_mut(&k) {
+        match self.buckets.get_mut(&k) {
             None => {},
             Some(v) => { v.push(t); return; },
         }

components/util/vec.rs

@@ -4,6 +4,9 @@
 
 use std::cmp::{PartialOrd, PartialEq};
 
+#[cfg(test)]
+use std::fmt::Show;
+
 /// FIXME(pcwalton): Workaround for lack of unboxed closures. This is called in
 /// performance-critical code, so a closure is insufficient.
 pub trait Comparator<K,T> {
@@ -71,11 +74,11 @@ fn test_find_all_elems<T: PartialEq + PartialOrd + Eq + Ord>(arr: &[T]) {
 }
 
 #[cfg(test)]
-fn test_miss_all_elems<T: PartialEq + PartialOrd + Eq + Ord>(arr: &[T], misses: &[T]) {
+fn test_miss_all_elems<T: PartialEq + PartialOrd + Eq + Ord + Show>(arr: &[T], misses: &[T]) {
     let mut i = 0;
     while i < misses.len() {
         let res = arr.binary_search_(&misses[i]);
-        debug!("{:?} == {:?} ?", misses[i], res);
+        debug!("{} == {} ?", misses[i], res);
         assert!(!test_match(&misses[i], arr.binary_search_(&misses[i])));
         i += 1;
     }

components/util/workqueue.rs

@@ -14,7 +14,7 @@ use libc::funcs::posix88::unistd::usleep;
 use rand::{Rng, XorShiftRng};
 use std::mem;
 use std::rand::weak_rng;
-use std::sync::atomics::{AtomicUint, SeqCst};
+use std::sync::atomic::{AtomicUint, SeqCst};
 use std::sync::deque::{Abort, BufferPool, Data, Empty, Stealer, Worker};
 
 /// A unit of work.
@@ -82,7 +82,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
             // Wait for a start message.
             let (mut deque, ref_count, queue_data) = match self.port.recv() {
                 StartMsg(deque, ref_count, queue_data) => (deque, ref_count, queue_data),
-                StopMsg => fail!("unexpected stop message"),
+                StopMsg => panic!("unexpected stop message"),
                 ExitMsg => return,
             };
 
@@ -105,7 +105,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
                         let mut should_continue = true;
                         loop {
                             let victim = (self.rng.next_u32() as uint) % self.other_deques.len();
-                            match self.other_deques.get_mut(victim).steal() {
+                            match self.other_deques[victim].steal() {
                                 Empty | Abort => {
                                     // Continue.
                                 }
@@ -130,7 +130,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
                                         break
                                     }
                                     Ok(ExitMsg) => return,
-                                    Ok(_) => fail!("unexpected message"),
+                                    Ok(_) => panic!("unexpected message"),
                                     _ => {}
                                 }
 
@@ -239,7 +239,7 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
         for i in range(0, thread_count) {
             for j in range(0, thread_count) {
                 if i != j {
-                    threads.get_mut(i).other_deques.push(infos[j].thief.clone())
+                    threads[i].other_deques.push(infos[j].thief.clone())
                 }
             }
             assert!(threads[i].other_deques.len() == thread_count - 1)
@@ -251,7 +251,7 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
             spawn_named_native(
                 format!("{} worker {}/{}", task_name, i+1, thread_count),
                 proc() {
-                    task_state::initialize(state | task_state::InWorker);
+                    task_state::initialize(state | task_state::IN_WORKER);
                     let mut thread = thread;
                     thread.start()
                 })
@@ -268,9 +268,10 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
     /// Enqueues a block into the work queue.
     #[inline]
     pub fn push(&mut self, work_unit: WorkUnit<QueueData, WorkData>) {
-        match self.workers.get_mut(0).deque {
+        let deque = &mut self.workers[0].deque;
+        match *deque {
             None => {
-                fail!("tried to push a block but we don't have the deque?!")
+                panic!("tried to push a block but we don't have the deque?!")
             }
             Some(ref mut deque) => deque.push(work_unit),
         }
@@ -297,8 +298,8 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
         // Get our deques back.
         for _ in range(0, self.workers.len()) {
             match self.port.recv() {
-                ReturnDequeMsg(index, deque) => self.workers.get_mut(index).deque = Some(deque),
-                FinishedMsg => fail!("unexpected finished message!"),
+                ReturnDequeMsg(index, deque) => self.workers[index].deque = Some(deque),
+                FinishedMsg => panic!("unexpected finished message!"),
             }
         }
     }