fix: unused warnings

src/engine/doc.rs

@@ -7,7 +7,6 @@ use crate::pretty_doc::DocRef;
 use crate::tree::{Bookmark, Location, Mode, Node};
 use crate::util::{bug_assert, SynlessBug};
 use std::collections::HashMap;
-use std::mem;
 
 /// A set of changes that can be undone/redone all at once.
 #[derive(Debug)]

src/engine/doc_command.rs

@@ -1,5 +1,5 @@
 use crate::language::Storage;
-use crate::tree::{Bookmark, Node};
+use crate::tree::Node;
 
 #[derive(Debug)]
 pub enum DocCommand {

src/engine/engine.rs

@@ -6,9 +6,7 @@ use super::Settings;
 use crate::language::{Language, LanguageError, LanguageSpec, NotationSetSpec, Storage};
 use crate::parsing::{Parse, ParseError};
 use crate::pretty_doc::{DocRef, PrettyDocError};
-use crate::style::Style;
-use crate::tree::{Bookmark, Node};
-use crate::util::SynlessBug;
+use crate::tree::Node;
 use partial_pretty_printer as ppp;
 use partial_pretty_printer::pane;
 use std::collections::HashMap;
@@ -154,7 +152,6 @@ impl Engine {
         language_name: &str,
         parser: impl Parse + 'static,
     ) -> Result<(), EngineError> {
-        let lang = self.storage.language(language_name)?;
         self.parsers
             .insert(language_name.to_owned(), Box::new(parser));
         Ok(())
@@ -164,19 +161,19 @@ impl Engine {
      * Doc Management *
      ******************/
 
-    pub fn make_empty_doc(&mut self, doc_name: &str, language: Language) {
+    pub fn make_empty_doc(&mut self, _doc_name: &str, _language: Language) {
         todo!()
     }
 
     /****************************
      * Doc Loading and Printing *
      ****************************/
 
-    pub fn load_doc_from_sexpr(&self, doc_name: &Path, source: &str) -> Result<(), EngineError> {
+    pub fn load_doc_from_sexpr(&self, _doc_name: &Path, _source: &str) -> Result<(), EngineError> {
         todo!()
     }
 
-    pub fn print_sexpr(&self, doc_name: &Path) -> Result<String, EngineError> {
+    pub fn print_sexpr(&self, _doc_name: &Path) -> Result<String, EngineError> {
         todo!()
     }
 
@@ -186,7 +183,6 @@ impl Engine {
         language_name: &str,
         source: &str,
     ) -> Result<(), EngineError> {
-        let lang = self.storage.language(language_name)?;
         let parser = self
             .parsers
             .get_mut(language_name)

src/frontends/frontend.rs

@@ -86,13 +86,13 @@ pub enum KeyCode {
 impl fmt::Display for Key {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.modifiers.ctrl {
-            write!(f, "C-");
+            write!(f, "C-")?;
         }
         if self.modifiers.alt {
-            write!(f, "A-");
+            write!(f, "A-")?;
         }
         if self.modifiers.shift {
-            write!(f, "S-");
+            write!(f, "S-")?;
         }
         match self.code {
             KeyCode::Backspace => write!(f, "bksp"),

src/frontends/screen_buf.rs

@@ -1,5 +1,5 @@
 use crate::style::ConcreteStyle;
-use partial_pretty_printer::{pane::PrettyWindow, Height, Pos, Size, Width};
+use partial_pretty_printer::{Height, Pos, Size, Width};
 use std::mem;
 
 /// The width of a single character. Either 1 ("half-width") or 2 ("full-width").

src/frontends/terminal.rs

@@ -2,14 +2,12 @@
 
 use super::frontend::{Event, Frontend, Key, KeyCode, KeyModifiers, MouseButton, MouseEvent};
 use super::screen_buf::{ScreenBuf, ScreenOp};
-use crate::style::{ColorTheme, ConcreteStyle, Rgb, Style};
+use crate::style::{ColorTheme, Rgb, Style};
 
 use partial_pretty_printer::pane::PrettyWindow;
 use partial_pretty_printer::{Col, Height, Pos, Row, Size};
 
-use std::convert::TryFrom;
-use std::fmt::Display;
-use std::io::{self, stdin, stdout, Stdin, Stdout, StdoutLock, Write};
+use std::io::{self, stdout, Write};
 use std::time::{Duration, Instant};
 
 use crossterm::cursor;
@@ -118,7 +116,7 @@ impl Frontend for Terminal {
             buf: ScreenBuf::new(Terminal::terminal_window_size()?, default_concrete_style),
             focus_pos: None,
         };
-        term.enter();
+        term.enter()?;
         Ok(term)
     }
 

src/language/compiled.rs

@@ -154,7 +154,7 @@ struct GrammarCompiler {
 }
 
 impl GrammarSpec {
-    fn compile(mut self) -> Result<GrammarCompiled, LanguageError> {
+    fn compile(self) -> Result<GrammarCompiled, LanguageError> {
         let mut builder = GrammarCompiler::new(self.root_construct);
         for construct in self.constructs {
             builder.add_construct(construct)?;
@@ -315,15 +315,18 @@ impl GrammarCompiler {
         }
 
         assert_eq!(construct_id, grammar.constructs.len());
-        grammar.constructs.insert(
-            construct.name.clone(),
-            ConstructCompiled {
-                name: construct.name.clone(),
-                arity,
-                is_comment_or_ws: construct.is_comment_or_ws,
-                key: construct.key,
-            },
-        );
+        grammar
+            .constructs
+            .insert(
+                construct.name.clone(),
+                ConstructCompiled {
+                    name: construct.name.clone(),
+                    arity,
+                    is_comment_or_ws: construct.is_comment_or_ws,
+                    key: construct.key,
+                },
+            )
+            .bug();
         Ok(())
     }
 }

src/language/interface.rs

@@ -1,12 +1,12 @@
 use super::compiled::{
-    compile_language, compile_notation_set, ArityCompiled, ConstructId, GrammarCompiled,
-    LanguageCompiled, LanguageId, NotationSetId, SortId,
+    compile_notation_set, ArityCompiled, ConstructId, GrammarCompiled, LanguageId, NotationSetId,
+    SortId,
 };
-use super::specs::{LanguageSpec, NotationSetSpec};
+use super::specs::NotationSetSpec;
 use super::storage::Storage;
 use super::LanguageError;
 use crate::style::ValidNotation;
-use crate::util::{bug, IndexedMap};
+use crate::util::bug;
 
 // NOTE: Why all the wrapper types, instead of using indexes? Two reasons:
 //

src/language/storage.rs

@@ -1,6 +1,6 @@
 use super::compiled::{compile_language, LanguageCompiled};
 use super::interface::Language;
-use super::specs::{LanguageSpec, NotationSetSpec};
+use super::specs::LanguageSpec;
 use super::LanguageError;
 use crate::tree::NodeForest;
 use crate::util::IndexedMap;

src/pretty_doc.rs

@@ -1,13 +1,11 @@
 use crate::language::Storage;
 use crate::style::{
-    Condition, CursorHalf, Style, StyleLabel, ValidNotation, HOLE_STYLE, LEFT_CURSOR_STYLE,
-    RIGHT_CURSOR_STYLE,
+    Condition, Style, StyleLabel, ValidNotation, HOLE_STYLE, LEFT_CURSOR_STYLE, RIGHT_CURSOR_STYLE,
 };
 use crate::tree::{Location, Node, NodeId};
-use crate::util::{bug, SynlessBug};
+use crate::util::SynlessBug;
 use partial_pretty_printer as ppp;
 use std::fmt;
-use std::sync::OnceLock;
 
 #[derive(thiserror::Error, Debug)]
 pub enum PrettyDocError {

src/tree/location.rs

@@ -251,7 +251,7 @@ impl Location {
         use LocationInner::{AfterNode, BeforeNode, BelowNode, InText};
 
         match self.0 {
-            InText(node, _) => None,
+            InText(_, _) => None,
             BeforeNode(node) | AfterNode(node) => node.parent(s),
             BelowNode(node) => Some(node),
         }

src/tree/node.rs

@@ -1,9 +1,8 @@
 use super::forest;
 use super::text::Text;
-use crate::language::{Arity, Construct, Language, LanguageSpec, NotationSetSpec, Storage};
-use crate::style::{Condition, StyleLabel, ValidNotation};
-use crate::util::{bug, SynlessBug};
-use partial_pretty_printer as ppp;
+use crate::language::{Arity, Construct, Language, Storage};
+use crate::style::ValidNotation;
+use crate::util::{bug, bug_assert, SynlessBug};
 use std::fmt;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -83,7 +82,7 @@ impl Node {
                         construct: hole_construct,
                         text: None,
                     });
-                    s.forest_mut().insert_last_child(parent, child);
+                    bug_assert!(s.forest_mut().insert_last_child(parent, child));
                 }
                 Node(parent)
             }
@@ -111,6 +110,9 @@ impl Node {
         children: impl IntoIterator<Item = Node>,
     ) -> Option<Node> {
         let children = children.into_iter().collect::<Vec<_>>();
+        if children.iter().any(|child| !child.is_root(s)) {
+            return None;
+        }
         let allowed = match construct.arity(s) {
             Arity::Texty => false,
             Arity::Listy(sort) => children
@@ -135,7 +137,10 @@ impl Node {
                 text: None,
             });
             for child in children {
-                s.forest_mut().insert_last_child(parent, child.0);
+                // Requires that:
+                // - Each child is a root, validated above
+                // - No child is the root of `parent`, which was just created
+                bug_assert!(s.forest_mut().insert_last_child(parent, child.0));
             }
             Some(Node(parent))
         } else {

src/util/bug.rs

@@ -112,6 +112,11 @@ macro_rules! bug {
 #[macro_export]
 /// Like `assert!()`, but with a better error message.
 macro_rules! bug_assert {
+    ($condition:expr) => {
+        if !$condition {
+            $crate::bug!("Assertion failed.");
+        }
+    };
     ($condition:expr, $message:literal) => {
         if !$condition {
             $crate::bug!($message);

src/util/indexed_map.rs

@@ -1,8 +1,5 @@
-use std::borrow::Borrow;
 use std::collections::HashMap;
-use std::hash::Hash;
 use std::ops::{Index, IndexMut};
-use std::vec;
 
 #[derive(Debug, Clone)]
 pub struct IndexedMap<T> {