upgrading to the newest Rust

iopq · iopq · commit 2166d4a1bf1a · 2015-04-04T20:07:36.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/board/mod.rs b/src/board/mod.rs
@@ -560,7 +560,8 @@ impl Board {
     fn remove_stone(&mut self, c: Coord) {
         // Resetting the chain_id is not strictly necessary, but will
         // make debugging easier.
-        self.board[c.to_index(self.size)].chain_id = -1;
+        //self.board[c.to_index(self.size)].chain_id = -1;
+        //removed because compiler error
         self.board[c.to_index(self.size)].color = Empty;
     }
     
diff --git a/src/board/movement/mod.rs b/src/board/movement/mod.rs
@@ -27,7 +27,7 @@ use board::Coord;
 
 mod test;
 
-#[derive(Debug, Eq, PartialEq, Hash, Copy)]
+#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
 pub enum Move {
     Pass(Color),
     Play(Color, u8, u8),
diff --git a/src/board/test/mod.rs b/src/board/test/mod.rs
@@ -142,7 +142,7 @@ fn legal_moves_should_return_nothing_after_a_resign() {
 
     b.play(Resign(Black));
 
-    assert_eq!(vec!(), b.legal_moves_without_superko_check());
+    assert_eq!(0, b.legal_moves_without_superko_check().len());
 }
 
 #[test]
@@ -151,7 +151,7 @@ fn legal_moves_without_eyes_should_return_nothing_after_a_resing() {
 
     b.play(Resign(Black));
 
-    assert_eq!(vec!(), b.legal_moves_without_eyes());
+    assert_eq!(0, b.legal_moves_without_eyes().len());
 }
 
 
diff --git a/src/engine/mc/amaf.rs b/src/engine/mc/amaf.rs
@@ -62,9 +62,9 @@ impl McEngine for AmafMcEngine {
     fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         for m in playout.moves().iter() {
             if won {
-                stats.record_win(&m);
+                stats.record_win(*m);
             } else {
-                stats.record_loss(&m);
+                stats.record_loss(*m);
             }
         }
     }
diff --git a/src/engine/mc/mod.rs b/src/engine/mc/mod.rs
@@ -103,7 +103,7 @@ fn finish(color: Color, game: &Game, stats: MoveStats, sender: Sender<Move>, hal
     }
 }
 
-fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats<'a>, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {
+fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {
     let mut guards = Vec::new();
     let mut halt_senders = Vec::new();
     for _ in 0..config.threads {
@@ -117,7 +117,7 @@ fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Mo
     (guards, halt_senders)
 }
 
-fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats<'a>, usize)>) -> thread::JoinGuard<'a, ()> {
+fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats, usize)>) -> thread::JoinGuard<'a, ()> {
     thread::scoped(move || {
         let runs = 100;
         let mut rng = weak_rng();
diff --git a/src/engine/mc/simple.rs b/src/engine/mc/simple.rs
@@ -62,9 +62,9 @@ impl McEngine for SimpleMcEngine {
     fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         let m = playout.moves()[0];
         if won {
-            stats.record_win(&m);
+            stats.record_win(m);
         } else {
-            stats.record_loss(&m);
+            stats.record_loss(m);
         }
     }
 
diff --git a/src/engine/move_stats/mod.rs b/src/engine/move_stats/mod.rs
@@ -28,16 +28,16 @@ use std::collections::HashMap;
 
 mod test;
 
-pub struct MoveStats<'a> {
+pub struct MoveStats {
     color: Color,
-    stats: HashMap<&'a Move, MoveStat>,
+    stats: HashMap<Move, MoveStat>,
 }
 
-impl<'a> MoveStats<'a> {
+impl MoveStats {
 
     pub fn new(moves: &Vec<Move>, color: Color) -> MoveStats {
         let mut stats = HashMap::new();
-        for m in moves.iter() {
+        for &m in moves.iter() {
             stats.insert(m, MoveStat::new());
         }
         MoveStats {
@@ -46,14 +46,14 @@ impl<'a> MoveStats<'a> {
         }
     }
 
-    pub fn record_win(&mut self, m: &Move) {
+    pub fn record_win(&mut self, m: Move) {
         match self.stats.get_mut(&m) {
             Some(stat) => stat.won(),
             None       => {}
         }
     }
 
-    pub fn record_loss(&mut self, m: &Move) {
+    pub fn record_loss(&mut self, m: Move) {
         match self.stats.get_mut(&m) {
             Some(stat) => stat.lost(),
             None       => {}
@@ -73,7 +73,7 @@ impl<'a> MoveStats<'a> {
         let mut move_stats = MoveStat::new();
         for (m_new, ms) in self.stats.iter() {
             if ms.win_ratio() > move_stats.win_ratio() {
-                m = **m_new;
+                m = *m_new;
                 move_stats = *ms;
             }
         }
@@ -92,7 +92,7 @@ impl<'a> MoveStats<'a> {
 }
 
 
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct MoveStat {
     wins: usize,
     plays: usize
diff --git a/src/engine/move_stats/test.rs b/src/engine/move_stats/test.rs
@@ -45,10 +45,10 @@ mod move_stats {
     fn returns_the_best_move() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
-        stats.record_loss(&Play(Black, 1, 1));
-        stats.record_win(&Play(Black, 2, 2));
-        stats.record_win(&Play(Black, 2, 2));
+        stats.record_win(Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
+        stats.record_win(Play(Black, 2, 2));
+        stats.record_win(Play(Black, 2, 2));
         let (m, ms) = stats.best();
         assert_eq!(Play(Black, 2, 2), m);
         assert_eq!(ms.plays, 2);
@@ -59,58 +59,58 @@ mod move_stats {
     fn all_wins_returns_true_when_no_losses_were_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
-        stats.record_win(&Play(Black, 2, 2));
+        stats.record_win(Play(Black, 1, 1));
+        stats.record_win(Play(Black, 2, 2));
         assert!(stats.all_wins());
     }
 
     #[test]
     fn all_wins_returns_false_when_a_loss_was_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
         assert!(!stats.all_wins());
     }
 
     #[test]
     fn all_losses_returns_true_when_no_wins_were_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
-        stats.record_loss(&Play(Black, 2, 2));
+        stats.record_loss(Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 2, 2));
         assert!(stats.all_losses());
     }
 
     #[test]
     fn all_losses_returns_false_when_a_win_was_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
+        stats.record_win(Play(Black, 1, 1));
         assert!(!stats.all_losses());
     }
 
     #[test]
     fn record_win_does_nothing_for_untracked_moves() {
         let moves = vec!();
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
+        stats.record_win(Play(Black, 1, 1));
     }
 
     #[test]
     fn record_loss_does_nothing_for_untracked_moves() {
         let moves = vec!();
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
     }
 
     #[test]
     fn merge_merges_stats_existing_in_both() {
         let m = Play(Black, 1, 1);
         let moves = vec!(m);
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&m);
+        stats.record_win(m);
         let mut other = MoveStats::new(&moves, Black);
-        other.record_loss(&m);
+        other.record_loss(m);
         stats.merge(&other);
         let ms = stats.stats.get(&m).unwrap();
         assert_eq!(ms.wins, 1);
@@ -124,7 +124,7 @@ mod move_stats {
         let mut stats = MoveStats::new(&moves, Black);
         let moves2 = vec!(m);
         let mut other = MoveStats::new(&moves2, Black);
-        other.record_loss(&m);
+        other.record_loss(m);
         stats.merge(&other);
         assert!(!stats.stats.get(&m).is_some());
     }

Original file line number	Diff line number	Diff line change
`@@ -560,7 +560,8 @@ impl Board {`
`560`	`560`	`fn remove_stone(&mut self, c: Coord) {`
`561`	`561`	`// Resetting the chain_id is not strictly necessary, but will`
`562`	`562`	`// make debugging easier.`
`563`		`- self.board[c.to_index(self.size)].chain_id = -1;`
	`563`	`+ //self.board[c.to_index(self.size)].chain_id = -1;`
	`564`	`+ //removed because compiler error`
`564`	`565`	`self.board[c.to_index(self.size)].color = Empty;`
`565`	`566`	`}`
`566`	`567`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ fn legal_moves_should_return_nothing_after_a_resign() {`
`142`	`142`
`143`	`143`	`b.play(Resign(Black));`
`144`	`144`
`145`		`- assert_eq!(vec!(), b.legal_moves_without_superko_check());`
	`145`	`+ assert_eq!(0, b.legal_moves_without_superko_check().len());`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`#[test]`
`@@ -151,7 +151,7 @@ fn legal_moves_without_eyes_should_return_nothing_after_a_resing() {`
`151`	`151`
`152`	`152`	`b.play(Resign(Black));`
`153`	`153`
`154`		`- assert_eq!(vec!(), b.legal_moves_without_eyes());`
	`154`	`+ assert_eq!(0, b.legal_moves_without_eyes().len());`
`155`	`155`	`}`
`156`	`156`
`157`	`157`
Original file line number	Diff line number	Diff line change
`@@ -62,9 +62,9 @@ impl McEngine for AmafMcEngine {`
`62`	`62`	`fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {`
`63`	`63`	`for m in playout.moves().iter() {`
`64`	`64`	`if won {`
`65`		`- stats.record_win(&m);`
	`65`	`+ stats.record_win(*m);`
`66`	`66`	`} else {`
`67`		`- stats.record_loss(&m);`
	`67`	`+ stats.record_loss(*m);`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ fn finish(color: Color, game: &Game, stats: MoveStats, sender: Sender<Move>, hal`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`		`-fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats<'a>, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {`
	`106`	`+fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {`
`107`	`107`	`let mut guards = Vec::new();`
`108`	`108`	`let mut halt_senders = Vec::new();`
`109`	`109`	`for _ in 0..config.threads {`
`@@ -117,7 +117,7 @@ fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Mo`
`117`	`117`	`(guards, halt_senders)`
`118`	`118`	`}`
`119`	`119`
`120`		`-fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats<'a>, usize)>) -> thread::JoinGuard<'a, ()> {`
	`120`	`+fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats, usize)>) -> thread::JoinGuard<'a, ()> {`
`121`	`121`	`thread::scoped(move \|\| {`
`122`	`122`	`let runs = 100;`
`123`	`123`	`let mut rng = weak_rng();`
Original file line number	Diff line number	Diff line change
`@@ -62,9 +62,9 @@ impl McEngine for SimpleMcEngine {`
`62`	`62`	`fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {`
`63`	`63`	`let m = playout.moves()[0];`
`64`	`64`	`if won {`
`65`		`- stats.record_win(&m);`
	`65`	`+ stats.record_win(m);`
`66`	`66`	`} else {`
`67`		`- stats.record_loss(&m);`
	`67`	`+ stats.record_loss(m);`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
Original file line number	Diff line number	Diff line change
`@@ -28,16 +28,16 @@ use std::collections::HashMap;`
`28`	`28`
`29`	`29`	`mod test;`
`30`	`30`
`31`		`-pub struct MoveStats<'a> {`
	`31`	`+pub struct MoveStats {`
`32`	`32`	`color: Color,`
`33`		`- stats: HashMap<&'a Move, MoveStat>,`
	`33`	`+ stats: HashMap<Move, MoveStat>,`
`34`	`34`	`}`
`35`	`35`
`36`		`-impl<'a> MoveStats<'a> {`
	`36`	`+impl MoveStats {`
`37`	`37`
`38`	`38`	`pub fn new(moves: &Vec<Move>, color: Color) -> MoveStats {`
`39`	`39`	`let mut stats = HashMap::new();`
`40`		`- for m in moves.iter() {`
	`40`	`+ for &m in moves.iter() {`
`41`	`41`	`stats.insert(m, MoveStat::new());`
`42`	`42`	`}`
`43`	`43`	`MoveStats {`
`@@ -46,14 +46,14 @@ impl<'a> MoveStats<'a> {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`- pub fn record_win(&mut self, m: &Move) {`
	`49`	`+ pub fn record_win(&mut self, m: Move) {`
`50`	`50`	`match self.stats.get_mut(&m) {`
`51`	`51`	`Some(stat) => stat.won(),`
`52`	`52`	`None => {}`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`- pub fn record_loss(&mut self, m: &Move) {`
	`56`	`+ pub fn record_loss(&mut self, m: Move) {`
`57`	`57`	`match self.stats.get_mut(&m) {`
`58`	`58`	`Some(stat) => stat.lost(),`
`59`	`59`	`None => {}`
`@@ -73,7 +73,7 @@ impl<'a> MoveStats<'a> {`
`73`	`73`	`let mut move_stats = MoveStat::new();`
`74`	`74`	`for (m_new, ms) in self.stats.iter() {`
`75`	`75`	`if ms.win_ratio() > move_stats.win_ratio() {`
`76`		`- m = **m_new;`
	`76`	`+ m = *m_new;`
`77`	`77`	`move_stats = *ms;`
`78`	`78`	`}`
`79`	`79`	`}`
`@@ -92,7 +92,7 @@ impl<'a> MoveStats<'a> {`
`92`	`92`	`}`
`93`	`93`
`94`	`94`
`95`		`-#[derive(Copy)]`
	`95`	`+#[derive(Copy, Clone)]`
`96`	`96`	`pub struct MoveStat {`
`97`	`97`	`wins: usize,`
`98`	`98`	`plays: usize`