Fix warnings, lints, and 2018 errors

debug_printer/Cargo.toml

@@ -3,6 +3,7 @@ name = "debug_printer"
 version = "0.0.1"  #:version
 authors = ["Manos Pitsidianakis <el13635@mail.ntua.gr>"]
 workspace = ".."
+edition = "2018"
 
 [lib]
 name = "debugprinter"

melib/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "melib"
 version = "0.0.1"  #:version
-edition = "2018"
 authors = ["Manos Pitsidianakis <el13635@mail.ntua.gr>"]
 workspace = ".."
+edition = "2018"
 
 [dependencies]
 bitflags = "1.0"

melib/src/addressbook.rs

@@ -173,7 +173,7 @@ impl Card {
         self.extra_properties.insert(key.to_string(), value);
     }
     pub fn extra_property(&self, key: &str) -> Option<&str> {
-        self.extra_properties.get(key).map(|v| v.as_str())
+        self.extra_properties.get(key).map(String::as_str)
     }
 }
 

melib/src/backends/maildir.rs

@@ -168,9 +168,7 @@ impl<'a> BackendOp for MaildirOp {
         let hash_index = self.hash_index.clone();
         let mut map = hash_index.lock().unwrap();
         let map = map.entry(self.folder_hash).or_default();
-        if let maildir_path = map.entry(old_hash).or_default() {
-            maildir_path.modified = Some(new_name.clone().into());
-        }
+        map.entry(old_hash).or_default().modified = Some(new_name.clone());
         Ok(())
     }
 }
@@ -247,11 +245,11 @@ impl BackendFolder for MaildirFolder {
             name: self.name.clone(),
             path: self.path.clone(),
             children: self.children.clone(),
-            parent: self.parent.clone(),
+            parent: self.parent,
         })
     }
 
     fn parent(&self) -> Option<FolderHash> {
-        self.parent.clone()
+        self.parent
     }
 }

melib/src/backends/maildir/backend.rs

@@ -29,7 +29,8 @@ use crate::conf::AccountSettings;
 use crate::email::{Envelope, EnvelopeHash};
 use crate::error::{MeliError, Result};
 
-use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
+extern crate notify;
+use self::notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
 use std::time::Duration;
 
 use std::sync::mpsc::channel;
@@ -166,7 +167,7 @@ fn move_to_cur(p: PathBuf) -> PathBuf {
         new.set_extension(":2,");
     }
     debug!("moved to cur: {}", new.display());
-    fs::rename(p, &new).unwrap();
+    fs::rename(&p, &new).unwrap();
     new
 }
 
@@ -263,11 +264,6 @@ impl MailBackend for MaildirType {
                                     } else {
                                         /* Did we just miss a Create event? In any case, create
                                          * envelope. */
-
-                                        /* Drop the lock manually as add_path_to_index would deadlock
-                                         * */
-                                        drop(index_lock);
-                                        drop(hash_indexes_lock);
                                         if let Some(env) = add_path_to_index(
                                             &hash_indexes,
                                             folder_hash,
@@ -369,10 +365,6 @@ impl MailBackend for MaildirType {
                                         .unwrap()
                                         .to_path_buf();
                                     debug!("filename = {:?}", file_name);
-                                    /* Drop the lock manually as add_path_to_index would deadlock
-                                     * */
-                                    drop(index_lock);
-                                    drop(hash_indexes_lock);
                                     if let Some(env) = add_path_to_index(
                                         &hash_indexes,
                                         folder_hash,

melib/src/collection.rs

@@ -130,56 +130,50 @@ impl Collection {
                 true
             }
         });
-        let mut threads = Threads::new(&mut envelopes);
+        let mut new_threads = Threads::new(&mut envelopes);
 
         for (h, e) in envelopes {
             self.envelopes.insert(h, e);
         }
-        for (t_fh, t) in self.threads.iter_mut() {
-            if self.sent_folder.map(|f| f == folder_hash).unwrap_or(false) {
-                let mut ordered_hash_set = threads
+        let &mut Collection {
+            ref mut threads,
+            ref mut envelopes,
+            ref sent_folder,
+            ..
+        } = self;
+        for (t_fh, t) in threads.iter_mut() {
+            if sent_folder.map(|f| f == folder_hash).unwrap_or(false) {
+                let mut ordered_hash_set = new_threads
                     .hash_set
                     .iter()
                     .cloned()
                     .collect::<Vec<EnvelopeHash>>();
-                unsafe {
-                    /* FIXME NLL
-                     * Sorting ordered_hash_set triggers a borrow which should not happen with NLL
-                     * probably */
-                    let envelopes = &self.envelopes as *const FnvHashMap<EnvelopeHash, Envelope>;
-                    ordered_hash_set.sort_by(|a, b| {
-                        (*envelopes)[a]
-                            .date()
-                            .partial_cmp(&(*(envelopes))[b].date())
-                            .unwrap()
-                    });
-                }
+                ordered_hash_set.sort_by(|a, b| {
+                    envelopes[a]
+                        .date()
+                        .partial_cmp(&envelopes[b].date())
+                        .unwrap()
+                });
                 for h in ordered_hash_set {
-                    t.insert_reply(&mut self.envelopes, h);
+                    t.insert_reply(envelopes, h);
                 }
                 continue;
             }
-            if self.sent_folder.map(|f| f == *t_fh).unwrap_or(false) {
+            if sent_folder.map(|f| f == *t_fh).unwrap_or(false) {
                 let mut ordered_hash_set =
                     t.hash_set.iter().cloned().collect::<Vec<EnvelopeHash>>();
-                unsafe {
-                    /* FIXME NLL
-                     * Sorting ordered_hash_set triggers a borrow which should not happen with NLL
-                     * probably */
-                    let envelopes = &self.envelopes as *const FnvHashMap<EnvelopeHash, Envelope>;
-                    ordered_hash_set.sort_by(|a, b| {
-                        (*envelopes)[a]
-                            .date()
-                            .partial_cmp(&(*(envelopes))[b].date())
-                            .unwrap()
-                    });
-                }
+                ordered_hash_set.sort_by(|a, b| {
+                    envelopes[a]
+                        .date()
+                        .partial_cmp(&envelopes[b].date())
+                        .unwrap()
+                });
                 for h in ordered_hash_set {
-                    threads.insert_reply(&mut self.envelopes, h);
+                    new_threads.insert_reply(envelopes, h);
                 }
             }
         }
-        self.threads.insert(folder_hash, threads);
+        threads.insert(folder_hash, new_threads);
     }
 
     pub fn update(&mut self, old_hash: EnvelopeHash, envelope: Envelope, folder_hash: FolderHash) {
@@ -190,7 +184,8 @@ impl Collection {
         self.envelopes.insert(new_hash, envelope);
         if self.sent_folder.map(|f| f == folder_hash).unwrap_or(false) {
             for (_, t) in self.threads.iter_mut() {
-                t.update_envelope(old_hash, new_hash, &self.envelopes);
+                t.update_envelope(old_hash, new_hash, &self.envelopes)
+                    .unwrap_or(());
             }
         }
         {

melib/src/email.rs

@@ -30,7 +30,7 @@ mod attachment_types;
 pub mod attachments;
 pub use crate::attachments::*;
 pub mod parser;
-use parser::BytesExt;
+use crate::parser::BytesExt;
 
 use crate::backends::BackendOp;
 use crate::error::{MeliError, Result};
@@ -472,8 +472,7 @@ impl Envelope {
                         let b = builder.build();
                         let subs = b.attachments();
 
-                        self.has_attachments =
-                            subs.iter().fold(false, |acc, sub| acc || !sub.is_text());
+                        self.has_attachments = subs.iter().any(|sub| !sub.is_text());
                     }
                     _ => {}
                 }

melib/src/email/attachments.rs

@@ -60,7 +60,7 @@ impl fmt::Debug for Attachment {
         {
             let mut text = Vec::with_capacity(4096);
             self.get_text_recursive(&mut text);
-            std::str::from_utf8(&text).map(|r| r.to_string()).unwrap_or_else(|e| format!("Unicode error {}", e))
+            std::str::from_utf8(&text).map(std::string::ToString::to_string).unwrap_or_else(|e| format!("Unicode error {}", e))
         }
         )
     }
@@ -346,7 +346,7 @@ impl Attachment {
         String::from_utf8_lossy(text.as_slice().trim()).into()
     }
     pub fn description(&self) -> Vec<String> {
-        self.attachments().iter().map(|a| a.text()).collect()
+        self.attachments().iter().map(Attachment::text).collect()
     }
     pub fn mime_type(&self) -> String {
         format!("{}", self.content_type).to_string()
@@ -408,7 +408,7 @@ impl Attachment {
                         return false;
                     }
                 }
-                return true;
+                true
             }
             ContentType::Multipart {
                 kind: MultipartType::Signed,
@@ -417,7 +417,7 @@ impl Attachment {
             } => subattachments
                 .iter()
                 .find(|s| s.content_type != ContentType::PGPSignature)
-                .map(|s| s.is_html())
+                .map(Attachment::is_html)
                 .unwrap_or(false),
             ContentType::Multipart {
                 ref subattachments, ..
@@ -468,11 +468,14 @@ fn decode_rfc822(_raw: &[u8]) -> Attachment {
 type Filter<'a> = Box<FnMut(&'a Attachment, &mut Vec<u8>) -> () + 'a>;
 
 fn decode_rec_helper<'a>(a: &'a Attachment, filter: &mut Option<Filter<'a>>) -> Vec<u8> {
-    let ret = match a.content_type {
+    match a.content_type {
         ContentType::Unsupported { .. } => Vec::new(),
         ContentType::Text { .. } => decode_helper(a, filter),
         ContentType::PGPSignature => a.content_type.to_string().into_bytes(),
-        ContentType::MessageRfc822 => decode_rec(&decode_rfc822(&a.raw), None),
+        ContentType::MessageRfc822 => {
+            let temp = decode_rfc822(&a.raw);
+            decode_rec(&temp, None)
+        }
         ContentType::Multipart {
             ref kind,
             ref subattachments,
@@ -497,8 +500,7 @@ fn decode_rec_helper<'a>(a: &'a Attachment, filter: &mut Option<Filter<'a>>) ->
                 vec
             }
         },
-    };
-    ret
+    }
 }
 
 pub fn decode_rec<'a>(a: &'a Attachment, mut filter: Option<Filter<'a>>) -> Vec<u8> {

melib/src/email/compose/mime.rs

@@ -2,7 +2,7 @@ use super::*;
 
 pub fn encode_header(value: &str) -> String {
     eprintln!("encoding \"{}\"", value);
-    let mut ret = String::with_capacity(5 / 3 * value.len());
+    let mut ret = String::with_capacity(value.len());
     for word in value.split_whitespace() {
         if word.is_ascii() {
             ret.push_str(word);

melib/src/email/parser.rs

@@ -896,11 +896,11 @@ mod tests {
     }
     #[test]
     fn test_attachments() {
-        use std::io::Read;
-        let mut buffer: Vec<u8> = Vec::new();
         //FIXME: add file
         return;
         /*
+        use std::io::Read;
+        let mut buffer: Vec<u8> = Vec::new();
         let _ = std::fs::File::open("").unwrap().read_to_end(&mut buffer);
         let boundary = b"b1_4382d284f0c601a737bb32aaeda53160";
         let (_, body) = match mail(&buffer).to_full_result() {

melib/src/grapheme_clusters.rs

@@ -9,7 +9,8 @@
 */
 
 use super::*;
-use unicode_segmentation::UnicodeSegmentation;
+extern crate unicode_segmentation;
+use self::unicode_segmentation::UnicodeSegmentation;
 
 pub trait Graphemes: UnicodeSegmentation + CodePointsIter {
     fn split_graphemes<'a>(&'a self) -> Vec<&'a str> {

melib/src/lib.rs

@@ -30,7 +30,7 @@ pub mod dbg {
                     "[{:?}] {}:{}_{}:	",
                     std::thread::current()
                     .name()
-                    .map(|v| v.to_string())
+                    .map(std::string::ToString::to_string)
                     .unwrap_or_else(|| format!("{:?}", std::thread::current().id())),
                     file!(),
                     line!(),
@@ -48,7 +48,7 @@ pub mod dbg {
                     "[{:?}] {}:{}_{}:	",
                     std::thread::current()
                     .name()
-                    .map(|v| v.to_string())
+                    .map(std::string::ToString::to_string)
                     .unwrap_or_else(|| format!("{:?}", std::thread::current().id())),
                     file!(),
                     line!(),
@@ -65,7 +65,7 @@ pub mod dbg {
                     "[{:?}] {}:{}_{}:	",
                     std::thread::current()
                     .name()
-                    .map(|v| v.to_string())
+                    .map(std::string::ToString::to_string)
                     .unwrap_or_else(|| format!("{:?}", std::thread::current().id())),
                     file!(),
                     line!(),
@@ -88,7 +88,7 @@ pub mod grapheme_clusters;
 pub mod mailbox;
 pub mod thread;
 pub use crate::email::*;
-pub use thread::*;
+pub use crate::thread::*;
 mod wcwidth;
 pub use self::grapheme_clusters::*;
 pub use self::wcwidth::*;
@@ -112,11 +112,11 @@ extern crate bitflags;
 extern crate fnv;
 extern crate uuid;
 
-pub use conf::*;
-pub use mailbox::*;
+pub use crate::conf::*;
+pub use crate::mailbox::*;
 
-pub use backends::{Backends, RefreshEvent, RefreshEventConsumer};
-pub use email::{Envelope, Flag};
-pub use error::{MeliError, Result};
+pub use crate::backends::{Backends, RefreshEvent, RefreshEventConsumer};
+pub use crate::email::{Envelope, Flag};
+pub use crate::error::{MeliError, Result};
 
-pub use addressbook::*;
+pub use crate::addressbook::*;

melib/src/structs.rs

@@ -1,7 +1,7 @@
 use std::iter::Extend;
 use std::ops::Index;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct StackVec<T: Default + Copy + std::fmt::Debug> {
     len: usize,
     array: [T; 32],
@@ -42,7 +42,7 @@ impl<T: Default + Copy + std::fmt::Debug> StackVec<T> {
             self.heap_vec.pop()
         } else {
             let ret = self.array[self.len - 1];
-            self.len = self.len - 1;
+            self.len -= 1;
             Some(ret)
         }
     }

melib/src/thread.rs

@@ -48,6 +48,7 @@ use std::mem;
 use std::ops::Index;
 use std::result::Result as StdResult;
 use std::str::FromStr;
+use std::string::ToString;
 
 type Envelopes = FnvHashMap<EnvelopeHash, Envelope>;
 
@@ -82,9 +83,12 @@ fn rec_change_root_parent(
     idx: ThreadHash,
     new_root: ThreadHash,
 ) {
-    let entry = b.entry(idx).or_default();
-    entry.thread_group = new_root;
-    if let Some(p) = entry.parent {
+    let parent = {
+        let entry = b.entry(idx).or_default();
+        entry.thread_group = new_root;
+        entry.parent
+    };
+    if let Some(p) = parent {
         rec_change_children(b, p, new_root);
         rec_change_root_parent(b, p, new_root);
     }
@@ -109,8 +113,8 @@ fn rec_change_children(
 macro_rules! remove_from_parent {
     ($buf:expr, $idx:expr) => {{
         let mut parent: Option<ThreadHash> = None;
-        let entry = $buf.entry($idx).or_default();
-        if let Some(p) = entry.parent {
+        let entry_parent = $buf.entry($idx).or_default().parent;
+        if let Some(p) = entry_parent {
             parent = Some(p);
             if let Some(pos) = $buf[&p].children.iter().position(|c| *c == $idx) {
                 $buf.entry(p).and_modify(|e| {
@@ -964,14 +968,14 @@ impl Threads {
             .get(
                 envelopes[&env_hash]
                     .in_reply_to()
-                    .map(|mgid| mgid.raw())
+                    .map(crate::email::StrBuild::raw)
                     .unwrap_or(&[]),
             )
-            .map(|h| *h);
+            .cloned();
         if let Some(id) = self
             .message_ids
             .get(envelopes[&env_hash].message_id().raw())
-            .map(|h| *h)
+            .cloned()
         {
             self.thread_nodes.entry(id).and_modify(|n| {
                 n.message = Some(env_hash);
@@ -1069,11 +1073,8 @@ impl Threads {
             }
         }
         let no_parent: bool = if let Some(node) = self.thread_nodes.get(&node_idx) {
-            match (node.parent, node.message, node.children.len()) {
-                (None, None, 0) => {
-                    return;
-                }
-                _ => {}
+            if let (None, None, 0) = (node.parent, node.message, node.children.len()) {
+                return;
             }
             node.parent.is_none()
         } else {
@@ -1085,10 +1086,10 @@ impl Threads {
 
         if no_parent {
             let tree = self.tree.get_mut();
-            if let Some(tree) = tree.iter_mut().find(|t| t.id == id) {
-                *tree = ThreadTree::new(id);
+            if let Some(pos) = tree.iter().position(|t| t.id == id) {
+                tree[pos] = ThreadTree::new(id);
                 node_build(
-                    tree,
+                    &mut tree[pos],
                     id,
                     *(self.sort.borrow()),
                     &mut self.thread_nodes,
@@ -1481,7 +1482,7 @@ impl Threads {
                 ref_ptr = parent_id;
                 continue;
             } */
-            if !self.thread_nodes[&ref_ptr].parent.is_none() {
+            if self.thread_nodes[&ref_ptr].parent.is_some() {
                 if self.thread_nodes[&parent_id].parent == Some(ref_ptr) {
                     eprintln!("ALARM");
                     remove_from_parent!(&mut self.thread_nodes, parent_id);
@@ -1506,12 +1507,9 @@ impl Threads {
         while i < tree.len() {
             // Evaluate if useless
             let node = &self.thread_nodes[&tree[i].id];
-            match (node.parent, node.message, node.children.len()) {
-                (None, None, 0) => {
-                    tree.remove(i);
-                    continue;
-                }
-                _ => {}
+            if let (None, None, 0) = (node.parent, node.message, node.children.len()) {
+                tree.remove(i);
+                continue;
             }
             i += 1;
         }
@@ -1570,14 +1568,9 @@ fn node_build(
                 }
             }
         }
-    } else {
-        if let Some(node) = thread_nodes.get(&idx) {
-            match (node.parent, node.message, node.children.len()) {
-                (None, None, 0) => {
-                    return;
-                }
-                _ => {}
-            }
+    } else if let Some(node) = thread_nodes.get(&idx) {
+        if let (None, None, 0) = (node.parent, node.message, node.children.len()) {
+            return;
         }
     }
 
@@ -1648,9 +1641,9 @@ fn print_threadnodes(
                   "\t".repeat(level),
                   node_hash,
                   "\t".repeat(level),
-                  nodes[&node_hash].message().as_ref().map(|m| format!("{} - {}\n{}\t\t{}", envelopes[m].message_id_display(), envelopes[m].subject(), "\t".repeat(level), envelopes[m].references().iter().map(|r| r.to_string()).collect::<Vec<String>>().join(", "))).unwrap_or_else(|| "None".to_string()),
+                  nodes[&node_hash].message().as_ref().map(|m| format!("{} - {}\n{}\t\t{}", envelopes[m].message_id_display(), envelopes[m].subject(), "\t".repeat(level), envelopes[m].references().iter().map(ToString::to_string).collect::<Vec<String>>().join(", "))).unwrap_or_else(|| "None".to_string()),
                   "\t".repeat(level),
-                  nodes[&node_hash].parent().as_ref().map(|p| p.to_string()).unwrap_or_else(|| "None".to_string()),
+                  nodes[&node_hash].parent().as_ref().map(ToString::to_string).unwrap_or_else(|| "None".to_string()),
                   "\t".repeat(level),
                   nodes[&node_hash].thread_group,
                   "\t".repeat(level),

testing/Cargo.toml

@@ -3,6 +3,7 @@ name = "testing"
 version = "0.0.1"  #:version
 authors = ["Manos Pitsidianakis <el13635@mail.ntua.gr>"]
 workspace = ".."
+edition = "2018"
 
 [[bin]]
 name = "emailparse"

ui/Cargo.toml

@@ -3,6 +3,7 @@ name = "ui"
 version = "0.0.1"  #:version
 authors = ["Manos Pitsidianakis <el13635@mail.ntua.gr>"]
 workspace = ".."
+edition = "2018"
 
 [dependencies]
 xdg = "2.1.0" # >:c

ui/src/components.rs

@@ -28,7 +28,7 @@ See the `Component` Trait for more details.
 use super::*;
 
 pub mod mail;
-pub use mail::*;
+pub use crate::mail::*;
 
 pub mod notifications;
 
@@ -39,7 +39,7 @@ pub mod utilities;
 pub use self::utilities::*;
 
 pub mod contacts;
-pub use contacts::*;
+pub use crate::contacts::*;
 
 use std::fmt;
 use std::fmt::{Debug, Display};

ui/src/components/contacts.rs

@@ -139,7 +139,7 @@ impl Component for ContactManager {
             match self.form.buttons_result() {
                 None => {}
                 Some(true) => {
-                    let mut fields = std::mem::replace(&mut self.form, FormWidget::default())
+                    let fields = std::mem::replace(&mut self.form, FormWidget::default())
                         .collect()
                         .unwrap();
                     let fields: FnvHashMap<String, String> = fields

ui/src/components/mail.rs

@@ -27,9 +27,9 @@ use melib::backends::FolderHash;
 use melib::thread::ThreadHash;
 
 pub mod listing;
-pub use listing::*;
+pub use crate::listing::*;
 pub mod view;
-pub use view::*;
+pub use crate::view::*;
 mod compose;
 pub use self::compose::*;
 

ui/src/components/mail/compose.rs

@@ -129,7 +129,7 @@ impl Composer {
      */
     pub fn edit(account_pos: usize, h: EnvelopeHash, context: &Context) -> Self {
         let mut ret = Composer::default();
-        let op = context.accounts[account_pos].operation(&h);
+        let op = context.accounts[account_pos].operation(h);
         let envelope: &Envelope = context.accounts[account_pos].get_env(&h);
 
         ret.draft = Draft::edit(envelope, op);
@@ -149,7 +149,7 @@ impl Composer {
         let mut ret = Composer::default();
         let p = &thread_nodes[&msg];
         let parent_message = &account.collection[&p.message().unwrap()];
-        let mut op = account.operation(&parent_message.hash());
+        let mut op = account.operation(parent_message.hash());
         let parent_bytes = op.as_bytes();
 
         ret.draft = Draft::new_reply(parent_message, parent_bytes.unwrap());
@@ -538,7 +538,7 @@ impl Component for Composer {
                     .spawn()
                     .expect("Failed to start mailer command");
                 {
-                    let mut stdin = msmtp.stdin.as_mut().expect("failed to open stdin");
+                    let stdin = msmtp.stdin.as_mut().expect("failed to open stdin");
                     self.update_draft();
                     let draft = self.draft.clone().finalise().unwrap();
                     stdin
@@ -582,8 +582,7 @@ impl Component for Composer {
                 }
                 /* update Draft's headers based on form values */
                 self.update_draft();
-                let mut f =
-                    create_temp_file(self.draft.to_string().unwrap().as_str().as_bytes(), None);
+                let f = create_temp_file(self.draft.to_string().unwrap().as_str().as_bytes(), None);
                 //let mut f = Box::new(std::fs::File::create(&dir).unwrap());
 
                 // TODO: check exit status

ui/src/components/mail/listing.rs

@@ -39,7 +39,7 @@ struct AccountMenuEntry {
 
 trait ListingTrait {
     fn coordinates(&self) -> (usize, usize, Option<EnvelopeHash>);
-    fn set_coordinates(&mut self, (usize, usize, Option<EnvelopeHash>));
+    fn set_coordinates(&mut self, _: (usize, usize, Option<EnvelopeHash>));
 }
 
 #[derive(Debug)]
@@ -48,7 +48,7 @@ pub enum ListingComponent {
     Threaded(ThreadListing),
     Compact(CompactListing),
 }
-use ListingComponent::*;
+use crate::ListingComponent::*;
 
 impl ListingTrait for ListingComponent {
     fn coordinates(&self) -> (usize, usize, Option<EnvelopeHash>) {

ui/src/components/mail/listing/compact.rs

@@ -20,7 +20,7 @@
  */
 
 use super::*;
-use components::utilities::PageMovement;
+use crate::components::utilities::PageMovement;
 use std::cmp;
 use std::ops::{Deref, DerefMut};
 
@@ -242,7 +242,7 @@ impl MailboxView {
                 }
                 threads.thread_nodes()[&iter_ptr].message().unwrap()
             };
-            if !context.accounts[self.cursor_pos.0].contains_key(&i) {
+            if !context.accounts[self.cursor_pos.0].contains_key(i) {
                 debug!("key = {}", i);
                 debug!(
                     "name = {} {}",
@@ -292,7 +292,7 @@ impl MailboxView {
                 }
                 threads.thread_nodes()[&iter_ptr].message().unwrap()
             };
-            if !context.accounts[self.cursor_pos.0].contains_key(&i) {
+            if !context.accounts[self.cursor_pos.0].contains_key(i) {
                 //debug!("key = {}", i);
                 //debug!(
                 //    "name = {} {}",
@@ -326,7 +326,7 @@ impl MailboxView {
             for x in x..min_width.0 {
                 self.columns[0][(x, idx)].set_bg(bg_color);
             }
-            let (mut x, _) = write_string_to_grid(
+            let (x, _) = write_string_to_grid(
                 &strings.1,
                 &mut self.columns[1],
                 fg_color,
@@ -460,7 +460,7 @@ impl MailboxView {
 
         let (upper_left, bottom_right) = area;
         let grid = grid.unwrap();
-        let (mut x, y) = upper_left;
+        let (mut x, _y) = upper_left;
         for i in 0..self.columns.len() {
             let (width, height) = self.columns[i].size();
             if self.widths[i] == 0 {
@@ -861,32 +861,28 @@ impl Component for MailboxView {
                     return true;
                 }
                 Action::ToggleThreadSnooze => {
-                    {
-                        //FIXME NLL
-                        let account = &mut context.accounts[self.cursor_pos.0];
-                        let folder_hash = account[self.cursor_pos.1]
-                            .as_ref()
-                            .map(|m| m.folder.hash())
-                            .unwrap();
-                        let threads = account.collection.threads.entry(folder_hash).or_default();
-                        let thread_group = threads.thread_nodes()
-                            [&threads.root_set(self.cursor_pos.2)]
-                            .thread_group();
-                        let thread_group = threads.find(thread_group);
-                        /*let i = if let Some(i) = threads.thread_nodes[&thread_group].message() {
-                            i
-                        } else {
-                            let mut iter_ptr = threads.thread_nodes[&thread_group].children()[0];
-                            while threads.thread_nodes()[&iter_ptr].message().is_none() {
-                                iter_ptr = threads.thread_nodes()[&iter_ptr].children()[0];
-                            }
-                            threads.thread_nodes()[&iter_ptr].message().unwrap()
-                        };*/
-                        let root_node = threads.thread_nodes.entry(thread_group).or_default();
-                        let is_snoozed = root_node.snoozed();
-                        root_node.set_snoozed(!is_snoozed);
-                        //self.row_updates.push(i);
-                    }
+                    let account = &mut context.accounts[self.cursor_pos.0];
+                    let folder_hash = account[self.cursor_pos.1]
+                        .as_ref()
+                        .map(|m| m.folder.hash())
+                        .unwrap();
+                    let threads = account.collection.threads.entry(folder_hash).or_default();
+                    let thread_group =
+                        threads.thread_nodes()[&threads.root_set(self.cursor_pos.2)].thread_group();
+                    let thread_group = threads.find(thread_group);
+                    /*let i = if let Some(i) = threads.thread_nodes[&thread_group].message() {
+                        i
+                    } else {
+                        let mut iter_ptr = threads.thread_nodes[&thread_group].children()[0];
+                        while threads.thread_nodes()[&iter_ptr].message().is_none() {
+                            iter_ptr = threads.thread_nodes()[&iter_ptr].children()[0];
+                        }
+                        threads.thread_nodes()[&iter_ptr].message().unwrap()
+                    };*/
+                    let root_node = threads.thread_nodes.entry(thread_group).or_default();
+                    let is_snoozed = root_node.snoozed();
+                    root_node.set_snoozed(!is_snoozed);
+                    //self.row_updates.push(i);
                     self.refresh_mailbox(context);
                     return true;
                 }

ui/src/components/mail/listing/plain.rs

@@ -246,8 +246,7 @@ impl PlainListing {
             1
         };
         // Populate `CellBuffer` with every entry.
-        let mut idx = 0;
-        for y in 0..=self.length {
+        for (idx, y) in (0..=self.length).enumerate() {
             if idx >= self.length {
                 /* No more entries left, so fill the rest of the area with empty space */
                 clear_area(&mut self.content, ((0, y), (MAX_COLS - 1, self.length)));
@@ -280,7 +279,7 @@ impl PlainListing {
                 self.content[(x, idx)].set_bg(bg_color);
             }
             let mut _x = widths.0 + column_sep;
-            let (mut x, _) = write_string_to_grid(
+            let (x, _) = write_string_to_grid(
                 &rows[idx].2,
                 &mut self.content,
                 fg_color,
@@ -317,8 +316,6 @@ impl PlainListing {
                 self.content[(x, y)].set_ch(' ');
                 self.content[(x, y)].set_bg(bg_color);
             }
-
-            idx += 1;
         }
     }
 
@@ -537,7 +534,7 @@ impl Component for PlainListing {
                     coordinates.1,
                     self.local_collection[self.cursor_pos.2],
                 );
-                self.view = Some(MailView::new(coordinates, None, None, context));
+                self.view = Some(MailView::new(coordinates, None, None));
             }
             self.view.as_mut().unwrap().draw(
                 grid,

ui/src/components/mail/listing/thread.rs

@@ -20,7 +20,7 @@
  */
 
 use super::*;
-use components::utilities::PageMovement;
+use crate::components::utilities::PageMovement;
 
 const MAX_COLS: usize = 500;
 
@@ -475,7 +475,7 @@ impl Component for ThreadListing {
                         (envelope.hash(), envelope.is_seen())
                     };
                     if !is_seen {
-                        let op = account.operation(&hash);
+                        let op = account.operation(hash);
                         let envelope: &mut Envelope =
                             account.get_env_mut(&self.locations[self.cursor_pos.2]);
                         envelope.set_seen(op).unwrap();
@@ -533,7 +533,7 @@ impl Component for ThreadListing {
             if let Some(ref mut v) = self.view {
                 v.update(coordinates);
             } else {
-                self.view = Some(MailView::new(coordinates, None, None, context));
+                self.view = Some(MailView::new(coordinates, None, None));
             }
 
             self.view.as_mut().unwrap().draw(

ui/src/components/mail/view.rs

@@ -21,6 +21,7 @@
 
 use super::*;
 use linkify::{Link, LinkFinder};
+
 use std::process::{Command, Stdio};
 
 mod html;
@@ -86,7 +87,6 @@ impl MailView {
         coordinates: (usize, usize, EnvelopeHash),
         pager: Option<Pager>,
         subview: Option<Box<Component>>,
-        context: &mut Context,
     ) -> Self {
         MailView {
             coordinates,
@@ -168,9 +168,10 @@ impl MailView {
                             v.extend(html_filter.wait_with_output().unwrap().stdout);
                         } else {
                             context.replies.push_back(UIEvent::Notification(
-                                Some(format!(
+                                Some(
                                     "Failed to find any application to use as html filter"
-                                )),
+                                        .to_string(),
+                                ),
                                 String::new(),
                             ));
                             return;
@@ -282,7 +283,7 @@ impl Component for MailView {
 
         let y: usize = {
             let account = &mut context.accounts[self.coordinates.0];
-            if !account.contains_key(&self.coordinates.2) {
+            if !account.contains_key(self.coordinates.2) {
                 /* The envelope has been renamed or removed, so wait for the appropriate event to
                  * arrive */
                 return;
@@ -292,11 +293,7 @@ impl Component for MailView {
                 (envelope.hash(), envelope.is_seen())
             };
             if !is_seen {
-                let folder_hash = {
-                    let mailbox = &mut account[self.coordinates.1].as_mut().unwrap();
-                    mailbox.folder.hash()
-                };
-                let op = account.operation(&hash);
+                let op = account.operation(hash);
                 let envelope: &mut Envelope = &mut account.get_env_mut(&self.coordinates.2);
                 envelope.set_seen(op).unwrap();
             }
@@ -392,7 +389,7 @@ impl Component for MailView {
                             envelope
                                 .references()
                                 .iter()
-                                .map(|r| r.to_string())
+                                .map(std::string::ToString::to_string)
                                 .collect::<Vec<String>>()
                                 .join(", ")
                         ),
@@ -421,7 +418,7 @@ impl Component for MailView {
             let body = {
                 let account = &mut context.accounts[self.coordinates.0];
                 let envelope: &Envelope = &account.get_env(&self.coordinates.2);
-                let op = account.operation(&envelope.hash());
+                let op = account.operation(envelope.hash());
                 envelope.body(op)
             };
             match self.mode {
@@ -446,7 +443,7 @@ impl Component for MailView {
                     let text = {
                         let account = &mut context.accounts[self.coordinates.0];
                         let envelope: &Envelope = &account.get_env(&self.coordinates.2);
-                        let mut op = account.operation(&envelope.hash());
+                        let mut op = account.operation(envelope.hash());
                         op.as_bytes()
                             .map(|v| String::from_utf8_lossy(v).into_owned())
                             .unwrap_or_else(|e| e.to_string())
@@ -618,7 +615,7 @@ impl Component for MailView {
                 {
                     let account = &mut context.accounts[self.coordinates.0];
                     let envelope: &Envelope = &account.get_env(&self.coordinates.2);
-                    let op = account.operation(&envelope.hash());
+                    let op = account.operation(envelope.hash());
                     if let Some(u) = envelope.body(op).attachments().get(lidx) {
                         match u.content_type() {
                             ContentType::MessageRfc822 => {
@@ -657,7 +654,7 @@ impl Component for MailView {
                                 let attachment_type = u.mime_type();
                                 let binary = query_default_app(&attachment_type);
                                 if let Ok(binary) = binary {
-                                    let mut p = create_temp_file(&decode(u, None), None);
+                                    let p = create_temp_file(&decode(u, None), None);
                                     Command::new(&binary)
                                         .arg(p.path())
                                         .stdin(Stdio::piped())
@@ -714,8 +711,8 @@ impl Component for MailView {
                     let account = &mut context.accounts[self.coordinates.0];
                     let envelope: &Envelope = &account.get_env(&self.coordinates.2);
                     let finder = LinkFinder::new();
-                    let op = account.operation(&envelope.hash());
-                    let mut t = envelope.body(op).text().to_string();
+                    let op = account.operation(envelope.hash());
+                    let t = envelope.body(op).text().to_string();
                     let links: Vec<Link> = finder.links(&t).collect();
                     if let Some(u) = links.get(lidx) {
                         u.as_str().to_string()
@@ -742,7 +739,7 @@ impl Component for MailView {
                 }
                 self.dirty = true;
             }
-            UIEvent::EnvelopeRename(old_hash, new_hash) => {
+            UIEvent::EnvelopeRename(old_hash, new_hash) if self.coordinates.2 == old_hash => {
                 self.coordinates.2 = new_hash;
             }
             _ => {

ui/src/components/mail/view/envelope.rs

@@ -336,7 +336,7 @@ impl Component for EnvelopeView {
                     let cursor_pos = if self.mode.is_attachment() {
                         Some(0)
                     } else {
-                        self.pager.as_mut().map(|p| p.cursor_pos())
+                        self.pager.as_ref().map(Pager::cursor_pos)
                     };
                     self.pager = Some(Pager::from_string(
                         text,
@@ -439,7 +439,7 @@ impl Component for EnvelopeView {
                                 let attachment_type = u.mime_type();
                                 let binary = query_default_app(&attachment_type);
                                 if let Ok(binary) = binary {
-                                    let mut p = create_temp_file(&decode(u, None), None);
+                                    let p = create_temp_file(&decode(u, None), None);
                                     Command::new(&binary)
                                         .arg(p.path())
                                         .stdin(Stdio::piped())
@@ -491,7 +491,7 @@ impl Component for EnvelopeView {
                 let url = {
                     let envelope: &Envelope = self.wrapper.envelope();
                     let finder = LinkFinder::new();
-                    let mut t = envelope
+                    let t = envelope
                         .body_bytes(self.wrapper.buffer())
                         .text()
                         .to_string();

ui/src/components/mail/view/html.rs

@@ -132,7 +132,7 @@ impl Component for HtmlView {
             // scripts)
             let binary = query_default_app("text/html");
             if let Ok(binary) = binary {
-                let mut p = create_temp_file(&self.bytes, None);
+                let p = create_temp_file(&self.bytes, None);
                 Command::new(&binary)
                     .arg(p.path())
                     .stdin(Stdio::piped())

ui/src/components/mail/view/thread.rs

@@ -20,7 +20,7 @@
  */
 
 use super::*;
-use components::utilities::PageMovement;
+use crate::components::utilities::PageMovement;
 use std::cmp;
 
 const INDENTATION_COLORS: &'static [u8] = &[
@@ -916,7 +916,7 @@ impl Component for ThreadView {
                             .unwrap()
                     };
                     let envelope: &Envelope = &account.get_env(&i);
-                    let op = account.operation(&envelope.hash());
+                    let op = account.operation(envelope.hash());
                     debug!(
                         "sending action edit for {}, {}",
                         envelope.message_id(),

ui/src/components/utilities.rs

@@ -336,7 +336,7 @@ impl Pager {
                 .spawn()
                 .expect("Failed to start pager filter process");
             {
-                let mut stdin = filter_child.stdin.as_mut().expect("failed to open stdin");
+                let stdin = filter_child.stdin.as_mut().expect("failed to open stdin");
                 stdin
                     .write_all(text.as_bytes())
                     .expect("Failed to write to stdin");

ui/src/components/utilities/widgets.rs

@@ -32,7 +32,7 @@ impl Debug for Field {
     }
 }
 
-use Field::*;
+use crate::Field::*;
 
 impl Default for Field {
     fn default() -> Field {
@@ -749,14 +749,14 @@ impl ScrollBar {
             return;
         }
         if self.show_arrows {
-            height = height - 2;
+            height -= height;
         }
         clear_area(grid, area);
 
         let visible_ratio: f32 = (std::cmp::min(visible_rows, length) as f32) / (length as f32);
         let scrollbar_height = std::cmp::max((visible_ratio * (height as f32)) as usize, 1);
         let scrollbar_offset = {
-            let mut temp = (((pos as f32) / (length as f32)) * (height as f32)) as usize;
+            let temp = (((pos as f32) / (length as f32)) * (height as f32)) as usize;
             if temp + scrollbar_height >= height {
                 height - scrollbar_height
             } else {

ui/src/conf.rs

@@ -37,9 +37,9 @@ pub use self::shortcuts::*;
 
 use self::default_vals::*;
 use self::notifications::NotificationsSettings;
+use crate::pager::PagerSettings;
 use melib::conf::AccountSettings;
 use melib::error::*;
-use pager::PagerSettings;
 
 use self::serde::{de, Deserialize, Deserializer};
 use std::collections::HashMap;
@@ -252,7 +252,7 @@ impl FileSettings {
                             .create_new(true)
                             .open(config_path.as_path())
                             .expect("Could not create config file.");
-                        file.write_all(include_str!("../../sample-config").as_bytes())
+                        file.write_all(include_bytes!("../../sample-config"))
                             .expect("Could not write to config file.");
                         println!("Written config to {}", config_path.display());
                         std::process::exit(1);
@@ -365,23 +365,23 @@ where
  */
 
 mod default_vals {
-    pub(in conf) fn false_val() -> bool {
+    pub(in crate::conf) fn false_val() -> bool {
         true
     }
 
-    pub(in conf) fn true_val() -> bool {
+    pub(in crate::conf) fn true_val() -> bool {
         true
     }
 
-    pub(in conf) fn zero_val() -> usize {
+    pub(in crate::conf) fn zero_val() -> usize {
         0
     }
 
-    pub(in conf) fn eighty_percent() -> usize {
+    pub(in crate::conf) fn eighty_percent() -> usize {
         80
     }
 
-    pub(in conf) fn none() -> Option<String> {
+    pub(in crate::conf) fn none() -> Option<String> {
         None
     }
 }

ui/src/conf/accounts.rs

@@ -37,6 +37,7 @@ use melib::thread::ThreadHash;
 use melib::AddressBook;
 use melib::StackVec;
 
+use crate::types::UIEvent::{self, EnvelopeRemove, EnvelopeRename, EnvelopeUpdate, Notification};
 use std::collections::VecDeque;
 use std::fs;
 use std::io;
@@ -44,7 +45,6 @@ use std::mem;
 use std::ops::{Index, IndexMut};
 use std::result;
 use std::sync::Arc;
-use types::UIEvent::{self, EnvelopeRemove, EnvelopeRename, EnvelopeUpdate, Notification};
 
 pub type Worker = Option<Async<(Result<FnvHashMap<EnvelopeHash, Envelope>>, Result<Mailbox>)>>;
 
@@ -215,17 +215,15 @@ impl Account {
             );
         }
         tree.sort_unstable_by_key(|f| ref_folders[&f.hash].name());
-        {
-            //FIXME: NLL
-            let mut stack: StackVec<Option<&FolderNode>> = StackVec::new();
-            for n in tree.iter_mut() {
-                folders_order.push(n.hash);
-                n.kids.sort_unstable_by_key(|f| ref_folders[&f.hash].name());
-                stack.extend(n.kids.iter().rev().map(Some));
-                while let Some(Some(next)) = stack.pop() {
-                    folders_order.push(next.hash);
-                    stack.extend(next.kids.iter().rev().map(Some));
-                }
+
+        let mut stack: StackVec<Option<&FolderNode>> = StackVec::new();
+        for n in tree.iter_mut() {
+            folders_order.push(n.hash);
+            n.kids.sort_unstable_by_key(|f| ref_folders[&f.hash].name());
+            stack.extend(n.kids.iter().rev().map(Some));
+            while let Some(Some(next)) = stack.pop() {
+                folders_order.push(next.hash);
+                stack.extend(next.kids.iter().rev().map(Some));
             }
         }
 
@@ -234,7 +232,7 @@ impl Account {
             if data.exists() {
                 let reader = io::BufReader::new(fs::File::open(data).unwrap());
                 let result: result::Result<AddressBook, _> = serde_json::from_reader(reader);
-                if let Ok(mut data_t) = result {
+                if let Ok(data_t) = result {
                     data_t
                 } else {
                     AddressBook::new(name.clone())
@@ -284,10 +282,7 @@ impl Account {
                     .collect::<FnvHashMap<EnvelopeHash, Envelope>>()
             });
             let hash = folder.hash();
-            let m = {
-                //FIXME NLL
-                Mailbox::new(folder, envelopes.as_ref().map_err(|e| e.clone()))
-            };
+            let m = Mailbox::new(folder, envelopes.as_ref().map_err(Clone::clone));
             tx.send(AsyncStatus::Payload((envelopes, m)));
             notify_fn.notify(hash);
         })))
@@ -318,36 +313,26 @@ impl Account {
                 }
                 RefreshEventKind::Create(envelope) => {
                     let env_hash = envelope.hash();
+                    let mailbox = mailbox!(&folder_hash, self.folders);
+                    mailbox.insert(env_hash);
+                    self.collection.insert(*envelope, folder_hash);
+                    if self
+                        .sent_folder
+                        .as_ref()
+                        .map(|h| *h == folder_hash)
+                        .unwrap_or(false)
                     {
-                        //FIXME NLL
-                        let mailbox = mailbox!(&folder_hash, self.folders);
-                        mailbox.insert(env_hash);
-                        self.collection.insert(*envelope, folder_hash);
-                        if self
-                            .sent_folder
-                            .as_ref()
-                            .map(|h| *h == folder_hash)
-                            .unwrap_or(false)
-                        {
-                            self.collection.insert_reply(env_hash);
-                        }
+                        self.collection.insert_reply(env_hash);
                     }
 
                     let ref_folders: FnvHashMap<FolderHash, Folder> = self.backend.folders();
-                    {
-                        //FIXME NLL
-                        let folder_conf =
-                            &self.settings.folder_confs[&self.folder_names[&folder_hash]];
-                        if folder_conf.ignore.is_true() {
-                            return None;
-                        }
+                    let folder_conf = &self.settings.folder_confs[&self.folder_names[&folder_hash]];
+                    if folder_conf.ignore.is_true() {
+                        return None;
                     }
-                    {
-                        //FIXME NLL
-                        let (_, thread_node) = self.mail_and_thread(env_hash, folder_hash);
-                        if thread_node.snoozed() {
-                            return None;
-                        }
+                    let (_, thread_node) = self.mail_and_thread(env_hash, folder_hash);
+                    if thread_node.snoozed() {
+                        return None;
                     }
                     let env = self.get_env(&env_hash);
                     return Some(Notification(
@@ -494,18 +479,18 @@ impl Account {
     pub fn get_env_mut(&mut self, h: &EnvelopeHash) -> &mut Envelope {
         self.collection.entry(*h).or_default()
     }
-    pub fn contains_key(&self, h: &EnvelopeHash) -> bool {
-        self.collection.contains_key(h)
+    pub fn contains_key(&self, h: EnvelopeHash) -> bool {
+        self.collection.contains_key(&h)
     }
-    pub fn operation(&self, h: &EnvelopeHash) -> Box<BackendOp> {
+    pub fn operation(&self, h: EnvelopeHash) -> Box<BackendOp> {
         for mailbox in self.folders.values() {
             if let Some(Ok(m)) = mailbox {
-                if m.envelopes.contains(h) {
-                    return self.backend.operation(*h, m.folder.hash());
+                if m.envelopes.contains(&h) {
+                    return self.backend.operation(h, m.folder.hash());
                 }
             }
         }
-        debug!("didn't find {}", *h);
+        debug!("didn't find {}", h);
         std::dbg!(&self.folders);
         std::dbg!(&self.collection.envelopes);
         unreachable!()

ui/src/conf/shortcuts.rs

@@ -1,4 +1,4 @@
-use terminal::Key;
+use crate::terminal::Key;
 //use std::any::TypeId;
 use fnv::FnvHashMap;
 

ui/src/execute.rs

@@ -25,9 +25,9 @@ pub use melib::mailbox::{SortField, SortOrder};
 use nom::{digit, not_line_ending};
 use std;
 pub mod actions;
-pub use actions::Action::{self, *};
-pub use actions::ListingAction::{self, *};
-pub use actions::TabAction::{self, *};
+pub use crate::actions::Action::{self, *};
+pub use crate::actions::ListingAction::{self, *};
+pub use crate::actions::TabAction::{self, *};
 
 named!(
     usize_c<usize>,

ui/src/execute/actions.rs

@@ -23,7 +23,7 @@
  * User actions that need to be handled by the UI
  */
 
-use components::Component;
+use crate::components::Component;
 pub use melib::mailbox::{SortField, SortOrder};
 use melib::thread::ThreadHash;
 use melib::EnvelopeHash;

ui/src/lib.rs

@@ -48,24 +48,24 @@ use std::collections::VecDeque;
 
 #[macro_use]
 mod types;
-pub use types::*;
+pub use crate::types::*;
 
 #[macro_use]
 mod terminal;
-pub use terminal::*;
+pub use crate::terminal::*;
 
 #[macro_use]
 mod execute;
-use execute::*;
+use crate::execute::*;
 
 pub mod state;
-pub use state::*;
+pub use crate::state::*;
 
 pub mod components;
-pub use components::*;
+pub use crate::components::*;
 
 pub mod conf;
-pub use conf::*;
+pub use crate::conf::*;
 
 pub mod workers;
-pub use workers::*;
+pub use crate::workers::*;

ui/src/state.rs

@@ -166,7 +166,7 @@ impl State {
          * Create async channel to block the input-thread if we need to fork and stop it from reading
          * stdin, see get_events() for details
          * */
-        let input_thread = chan::async();
+        let input_thread = chan::r#async();
         let _stdout = std::io::stdout();
         _stdout.lock();
         let backends = Backends::new();
@@ -372,7 +372,6 @@ impl State {
         /* Sort by x_start, ie upper_left corner's x coordinate */
         areas.sort_by(|a, b| (a.0).0.partial_cmp(&(b.0).0).unwrap());
         /* draw each dirty area */
-        let cols = self.cols;
         let rows = self.rows;
         for y in 0..rows {
             let mut segment = None;
@@ -425,7 +424,6 @@ impl State {
                 write!(self.stdout(), "{}", termion::color::Fg(c.fg().as_termion())).unwrap();
             }
             write!(self.stdout(), "{}", c.ch()).unwrap();
-            let mut b = [0; 4];
             if c.bg() != Color::Default {
                 write!(
                     self.stdout(),
@@ -526,7 +524,7 @@ impl State {
     pub fn try_wait_on_child(&mut self) -> Option<bool> {
         let should_return_flag = match self.child {
             Some(ForkType::NewDraft(_, ref mut c)) => {
-                let mut w = c.try_wait();
+                let w = c.try_wait();
                 match w {
                     Ok(Some(_)) => true,
                     Ok(None) => false,
@@ -536,7 +534,7 @@ impl State {
                 }
             }
             Some(ForkType::Generic(ref mut c)) => {
-                let mut w = c.try_wait();
+                let w = c.try_wait();
                 match w {
                     Ok(Some(_)) => true,
                     Ok(None) => false,

ui/src/terminal.rs

@@ -22,7 +22,7 @@ extern crate serde;
 use self::serde::de::Visitor;
 use self::serde::{de, Deserialize, Deserializer};
 extern crate unicode_segmentation;
-use melib::grapheme_clusters::*;
+
 
 #[macro_use]
 mod position;

ui/src/terminal/cells.rs

@@ -25,6 +25,7 @@
 */
 
 use super::position::*;
+
 use std::convert::From;
 use std::fmt;
 use std::ops::{Deref, DerefMut, Index, IndexMut};

ui/src/terminal/keys.rs

@@ -72,7 +72,7 @@ pub enum Key {
 
 impl fmt::Display for Key {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Key::*;
+        use crate::Key::*;
         match self {
             F(n) => write!(f, "F{}", n),
             Char('\t') => write!(f, "Tab"),

ui/src/terminal/text_editing.rs

@@ -1,4 +1,4 @@
-use super::*;
+use melib::Graphemes;
 
 #[derive(Debug, Clone, Default, PartialEq)]
 pub struct UText {

ui/src/workers.rs

@@ -152,7 +152,7 @@ impl<T: Send> WorkQueue<T> {
 
 impl WorkController {
     pub fn new() -> WorkController {
-        let (new_jobs_tx, new_jobs_rx) = chan::async();
+        let (new_jobs_tx, new_jobs_rx) = chan::r#async();
         // Create a new work queue to keep track of what work needs to be done.
         // Note that the queue is internally mutable (or, rather, the Mutex is),
         // but this binding doesn't need to be mutable. This isn't unsound because
@@ -163,7 +163,7 @@ impl WorkController {
         // Create a MPSC (Multiple Producer, Single Consumer) channel. Every worker
         // is a producer, the main thread is a consumer; the producers put their
         // work into the channel when it's done.
-        let (results_tx, results_rx) = chan::async();
+        let (results_tx, results_rx) = chan::r#async();
 
         // Create a SyncFlag to share whether or not there are more jobs to be done.
         let (thread_end_tx, thread_end_rx) = chan::sync(::std::mem::size_of::<bool>());