Fix warning '...not permit being left uninit..d'

Put SocketState initialisation logic in new. This avoids using an unsafe
and unnerving MaybeUninit::uninit().assume_init() to initialise an
array, which the compiler yells at since it causes undefined behavior.

Cargo.lock

@@ -327,10 +327,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "panic-abort"
-version = "0.3.2"
+name = "panic-halt"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e20e6499bbbc412f280b04a42346b356c6fa0753d5fd22b7bd752ff34c778ee"
+checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
 
 [[package]]
 name = "panic-semihosting"
@@ -563,7 +563,7 @@ dependencies = [
  "nb 1.0.0",
  "nom",
  "num-traits",
- "panic-abort",
+ "panic-halt",
  "panic-semihosting",
  "serde",
  "serde-json-core",

Cargo.toml

@@ -7,14 +7,14 @@ authors = ["Astro <astro@spaceboyz.net>"]
 version = "0.0.0"
 keywords = ["thermostat", "laser", "physics"]
 repository = "https://git.m-labs.hk/M-Labs/thermostat"
-edition = "2018"
+edition = "2021"
 
 [package.metadata.docs.rs]
 features = []
 default-target = "thumbv7em-none-eabihf"
 
 [dependencies]
-panic-abort = "0.3"
+panic-halt = "0.2"
 panic-semihosting = { version = "0.5", optional = true }
 log = "0.4"
 bare-metal = "1"

flake.nix

@@ -8,8 +8,8 @@
     let
       pkgs = import nixpkgs { system = "x86_64-linux"; overlays = [ (import mozilla-overlay) ]; };
       rustManifest = pkgs.fetchurl {
-        url = "https://static.rust-lang.org/dist/2021-10-26/channel-rust-nightly.toml";
-        sha256 = "sha256-1hLbypXA+nuH7o3AHCokzSBZAvQxvef4x9+XxO3aBao=";
+        url = "https://static.rust-lang.org/dist/2022-12-15/channel-rust-stable.toml";
+        hash = "sha256-S7epLlflwt0d1GZP44u5Xosgf6dRrmr8xxC+Ml2Pq7c=";
       };
 
       targets = [
@@ -22,12 +22,12 @@
           inherit targets;
           extensions = ["rust-src"];
         };
-      rust = rustChannelOfTargets "nightly" null targets;
+      rust = rustChannelOfTargets "stable" null targets;
       rustPlatform = pkgs.recurseIntoAttrs (pkgs.makeRustPlatform {
         rustc = rust;
         cargo = rust;
       });
-      thermostat = rustPlatform.buildRustPackage rec {
+      thermostat = rustPlatform.buildRustPackage {
         name = "thermostat";
         version = "0.0.0";
 

src/dfu.rs

@@ -1,3 +1,4 @@
+use core::arch::asm;
 use cortex_m_rt::pre_init;
 use stm32f4xx_hal::stm32::{RCC, SYSCFG};
 

src/main.rs

@@ -1,11 +1,10 @@
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)]
-#![feature(maybe_uninit_extra, asm)]
 #![cfg_attr(test, allow(unused))]
 // TODO: #![deny(warnings, unused)]
 
 #[cfg(not(any(feature = "semihosting", test)))]
-use panic_abort as _;
+use panic_halt as _;
 #[cfg(all(feature = "semihosting", not(test)))]
 use panic_semihosting as _;
 

src/server.rs

@@ -1,4 +1,3 @@
-use core::mem::MaybeUninit;
 use smoltcp::{
     iface::EthernetInterface,
     socket::{SocketSet, SocketHandle, TcpSocket, TcpSocketBuffer, SocketRef},
@@ -13,6 +12,18 @@ pub struct SocketState<S> {
     state: S,
 }
 
+impl<'a, S: Default> SocketState<S>{
+    fn new(sockets: &mut SocketSet<'a>, tcp_rx_storage: &'a mut [u8; TCP_RX_BUFFER_SIZE], tcp_tx_storage: &'a mut [u8; TCP_TX_BUFFER_SIZE]) -> SocketState<S> {
+        let tcp_rx_buffer = TcpSocketBuffer::new(&mut tcp_rx_storage[..]);
+        let tcp_tx_buffer = TcpSocketBuffer::new(&mut tcp_tx_storage[..]);
+        let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
+        SocketState::<S> {
+            handle: sockets.add(tcp_socket),
+            state: S::default()
+        }
+    }
+}
+
 /// Number of server sockets and therefore concurrent client
 /// sessions. Many data structures in `Server::run()` correspond to
 /// this const.
@@ -35,28 +46,27 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
     where
         F: FnOnce(&mut Server<'a, '_, S>),
     {
-        let mut sockets_storage: [_; SOCKET_COUNT] = Default::default();
-        let mut sockets = SocketSet::new(&mut sockets_storage[..]);
-        let mut states: [SocketState<S>; SOCKET_COUNT] = unsafe { MaybeUninit::uninit().assume_init() };
-
-        macro_rules! create_socket {
-            ($set:ident, $rx_storage:ident, $tx_storage:ident, $target:expr) => {
+        macro_rules! create_rtx_storage {
+            ($rx_storage:ident, $tx_storage:ident) => {
                 let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE];
                 let mut $tx_storage = [0; TCP_TX_BUFFER_SIZE];
-                let tcp_rx_buffer = TcpSocketBuffer::new(&mut $rx_storage[..]);
-                let tcp_tx_buffer = TcpSocketBuffer::new(&mut $tx_storage[..]);
-                let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
-                $target = $set.add(tcp_socket);
             }
         }
-        create_socket!(sockets, tcp_rx_storage0, tcp_tx_storage0, states[0].handle);
-        create_socket!(sockets, tcp_rx_storage1, tcp_tx_storage1, states[1].handle);
-        create_socket!(sockets, tcp_rx_storage2, tcp_tx_storage2, states[2].handle);
-        create_socket!(sockets, tcp_rx_storage3, tcp_tx_storage3, states[3].handle);
 
-        for state in &mut states {
-            state.state = S::default();
-        }
+        create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0);
+        create_rtx_storage!(tcp_rx_storage1, tcp_tx_storage1);
+        create_rtx_storage!(tcp_rx_storage2, tcp_tx_storage2);
+        create_rtx_storage!(tcp_rx_storage3, tcp_tx_storage3);
+
+        let mut sockets_storage: [_; SOCKET_COUNT] = Default::default();
+        let mut sockets = SocketSet::new(&mut sockets_storage[..]);
+
+        let states: [SocketState<S>; SOCKET_COUNT] = [
+            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage0, &mut tcp_tx_storage0),
+            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage1, &mut tcp_tx_storage1),
+            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage2, &mut tcp_tx_storage2),
+            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage3, &mut tcp_tx_storage3),
+        ];
 
         let mut server = Server {
             states,