Fix warnings

Author: phil-opp

src/future_mutex.rs

@@ -1,22 +1,11 @@
-use spin::{Mutex, MutexGuard};
+use spin::Mutex;
 use core::{
     future::Future,
-    sync::atomic::AtomicBool,
     pin::{Pin, Unpin},
     mem,
 };
-use alloc::{
-    prelude::*,
-    sync::Arc,
-    task::{Wake, LocalWaker, local_waker_from_nonlocal},
-    collections::{BTreeMap, BTreeSet},
-};
-use futures::{
-    prelude::*,
-    future::{FutureObj, LocalFutureObj, UnsafeFutureObj},
-    task::{Poll, Spawn, LocalSpawn, SpawnError},
-    channel::mpsc,
-};
+use alloc::task::LocalWaker;
+use futures::task::Poll;
 use crate::mpsc_queue::{Queue, PopResult};
 
 pub struct FutureMutex<T> {
@@ -60,7 +49,7 @@ impl<'a, T, R, F> Future for FutureMutexResult<'a, T, R, F> where F: FnOnce(&mut
                 Poll::Pending
             },
             Some(mut guard) => {
-                let mut f = self.f.take().unwrap();
+                let f = self.f.take().unwrap();
                 let ret = f(&mut guard);
                 loop {
                     match self.waker_queue.pop() {

src/lcd/mod.rs

@@ -5,7 +5,6 @@ pub use self::stdout::init as init_stdout;
 use core::{fmt, ptr};
 use stm32f7::stm32f7x6::LTDC;
 use alloc::sync::Arc;
-use futures::Future;
 use crate::future_mutex::FutureMutex;
 
 #[macro_use]

src/main.rs

@@ -38,7 +38,7 @@ use smoltcp::{
     time::Instant,
     wire::{EthernetAddress, IpAddress, IpEndpoint, Ipv4Address},
 };
-use stm32f7::stm32f7x6::{self, CorePeripherals, Interrupt, Peripherals, SAI2};
+use stm32f7::stm32f7x6::{CorePeripherals, Interrupt, Peripherals, SAI2};
 use stm32f7_discovery::{
     ethernet,
     gpio::{GpioPort, InputPin, OutputPin},
@@ -53,15 +53,9 @@ use stm32f7_discovery::{
     future_mutex::FutureMutex,
     i2c::I2C,
 };
-use core::ops::{Generator, GeneratorState};
-use core::future::Future;
 use futures::{Stream, StreamExt};
 use pin_utils::pin_mut;
-use spin::Mutex;
 use alloc::sync::Arc;
-use alloc::collections::VecDeque;
-use core::task::{Poll, LocalWaker};
-use core::pin::Pin;
 
 #[global_allocator]
 static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
@@ -94,7 +88,7 @@ fn run() -> ! {
     let mut ethernet_dma = peripherals.ETHERNET_DMA;
     let mut nvic_stir = peripherals.NVIC_STIR;
     let mut tim6 = peripherals.TIM6;
-    let mut exti = peripherals.EXTI;
+    let exti = peripherals.EXTI;
 
     init::init_system_clock_216mhz(&mut rcc, &mut pwr, &mut flash);
     init::enable_gpio_ports(&mut rcc);
@@ -128,7 +122,7 @@ fn run() -> ! {
     unsafe { ALLOCATOR.init(rt::heap_start() as usize, HEAP_SIZE) }
 
     lcd.set_background_color(Color::from_hex(0x006600));
-    let mut layer_1 = lcd.layer_1().unwrap();
+    let layer_1 = lcd.layer_1().unwrap();
     let mut layer_2 = lcd.layer_2().unwrap();
 
     layer_2.clear();
@@ -137,7 +131,7 @@ fn run() -> ! {
     println!("Hello World");
 
 
-    let xs = vec![1, 2, 3];
+    let _xs = vec![1, 2, 3];
 
     let mut i2c_3 = init::init_i2c_3(Box::leak(Box::new(peripherals.I2C3)), &mut rcc);
     i2c_3.test_1();
@@ -192,9 +186,9 @@ fn run() -> ! {
             };
 
             let (idle_waker_sink, mut idle_waker_stream) = mpsc::unbounded();
-            let (tim6_sink, mut tim6_stream) = mpsc::unbounded();
-            let (button_sink, mut button_stream) = mpsc::unbounded();
-            let (touch_int_sink, mut touch_int_stream) = mpsc::unbounded();
+            let (tim6_sink, tim6_stream) = mpsc::unbounded();
+            let (button_sink, button_stream) = mpsc::unbounded();
+            let (touch_int_sink, touch_int_stream) = mpsc::unbounded();
 
             interrupt_table.register(InterruptRequest::TIM6_DAC, Priority::P1, move || {
                 tim6_sink.unbounded_send(()).expect("sending on tim6 channel failed");
@@ -252,7 +246,7 @@ fn run() -> ! {
 
             // ethernet
             let mut ethernet_task_idle_stream = task_runtime::IdleStream::new(idle_waker_sink.clone());
-            let ethernet_task = async move || {
+            let _ethernet_task = async move || {
                 let mut ethernet_interface = ethernet::EthernetDevice::new(
                     Default::default(),
                     Default::default(),
@@ -328,7 +322,7 @@ fn run() -> ! {
             //executor.spawn_local(ethernet_task).unwrap();
             //executor.spawn_local(print_x);
 
-            let mut idle = async move {
+            let idle = async move {
                 loop {
                     let next_waker = await!(idle_waker_stream.next()).expect("idle channel closed");
                     next_waker.wake();

src/task_runtime.rs

@@ -4,11 +4,11 @@ use alloc::{
     prelude::*,
     sync::Arc,
     task::{Wake, LocalWaker, local_waker_from_nonlocal},
-    collections::{BTreeMap, BTreeSet},
+    collections::BTreeMap,
 };
 use futures::{
     prelude::*,
-    future::{FutureObj, LocalFutureObj, UnsafeFutureObj},
+    future::{FutureObj, LocalFutureObj},
     task::{Poll, Spawn, LocalSpawn, SpawnError},
     channel::mpsc,
 };