Updated nightly, new warning.
Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
 
       let y : Authorisation<(Passwd,Uid,InUserList)> = {
 
-        struct AuthorisedIf { authorised_for : Option<Uid> };
+        struct AuthorisedIf { authorised_for : Option<Uid> }
 
         const SERVER_ONLY : (AuthorisedIf, Authorisation<InUserList>) = (
           AuthorisedIf { authorised_for: None },
 
     subcommand: String,
     subargs: Vec<String>,
     spec_dir: Option<String>,
-  };
+  }
   let (subcommand, subargs, mo) = parse_args::<RawMainArgs,_>(
     env::args().collect(),
   &|rma|{
     enum Situation {
       Poor(Vec<MGI>, &'static str),
       Good([Pos; 2]),
-    };
+    }
     use Situation::*;
 
     const WANTED: usize = 2;
     struct Placement {
       lhs: Coord, top: Coord, rhs: Coord, bot: Coord,
       clhs: Coord, cbot: Coord, // current line
-    };
+    }
 
     let mut placement = match situation {
       Poor(insns, msg) => {
 
     uos: Vec<String>,
     bbox: Vec<Vec<f64>>,
     size: Vec<f64>,
-  };
+  }
 
   const SEVERAL: usize = 3;
 
 
       player_num: u32,
       nick: &'r str,
       account: &'r AccountName,
-    };
+    }
     let players = self.gs.players.iter().filter_map(|(player, gpl)| {
       let ipl = self.iplayers.get(player)?;
       let (idx, _) = player.data().get_idx_version();
 #[throws(anyhow::Error)]
 pub fn load_games(accounts: &mut AccountsGuard,
                   games: &mut GamesGuard) {
-  enum AFState { Found(PathBuf), Used };
+  enum AFState { Found(PathBuf), Used }
   use AFState::*;
   use SavefilenameParseResult::*;
   let mut a_leaves = HashMap::new();
 
     bits: BM,
     len: BI,
     index: BI,
-  };
+  }
   impl RotatingBitmap {
     const fn new(bits: BM, len: BI) -> Self { Self{ bits, len, index:0 } }
     fn reset(&mut self) { self.index= 0; }
 
             dirname: dirname.to_string(),
             catalogue: path,
           }
-        };
+        }
 
         let results = glob::glob_with(pat, glob::MatchOptions {
           require_literal_separator: true,
 
         game_name: String,
         nick: &'r str,
         token_lines: Vec<String>,
-      };
+      }
       let common = CommonData {
         player_email: &self.addr,
         game_name: g.name.to_string(),
             unix_user: &'r str,
             #[serde(flatten)]
             common: CommonData<'r>,
-          };
+          }
           let data = Data {
             unix_user: user,
             common,
             account: String,
             #[serde(flatten)]
             common: CommonData<'r>,
-          };
+          }
           let data = Data {
             account: account.to_string(),
             common,
 
             Recorded(ClientSequence, Option<&'u PreparedPieceState>),
             Exactly(TransmitUpdateEntry<'u>),
             Piece,
-          };
+          }
           let ftg = match by_client {
             None                                     => FTG::Piece,
             Some((_,u_client,_)) if u_client != dest => FTG::Piece,
 
       let last = a.as_ref().map(|m| m.repack().unwrap());
       let i = Mutable::some_range(a.as_ref(), b.as_ref(), count)?;
       It { i, last }
-    };
+    }
     impl It {
       fn nxt(&mut self, exp: Option<&str>) {
         let got = self.i.next();