Cleaning up compiler warnings.

src/compare/diff.rs

@@ -28,6 +28,7 @@ use crate::DynamicBlock;
 pub struct DiffResult {
     status: DiffStatus,
     name: String,
+    #[allow(dead_code)]
     message: Option<String>,
     children: Vec<DiffResult>,
 }

src/compare/parse.rs

@@ -1,17 +1,6 @@
 use std::path::Path;
 use std::process::Command;
 
-use crate::compare::sexp::sexp;
-
-pub fn compare_parse_org_document<'a, C>(file_path: C) -> Result<String, Box<dyn std::error::Error>>
-where
-    C: AsRef<Path>,
-{
-    let org_sexp = emacs_parse_org_document(file_path)?;
-    let parsed_sexp = sexp(org_sexp.as_str()).expect("Parse failure");
-    todo!()
-}
-
 pub fn emacs_parse_org_document<'a, C>(file_path: C) -> Result<String, Box<dyn std::error::Error>>
 where
     C: AsRef<Path>,

src/compare/sexp.rs

@@ -27,7 +27,9 @@ pub enum Token<'s> {
 
 #[derive(Debug)]
 pub struct TextWithProperties<'s> {
+    #[allow(dead_code)]
     text: &'s str,
+    #[allow(dead_code)]
     properties: Vec<Token<'s>>,
 }
 

src/init_tracing.rs

@@ -1,6 +1,6 @@
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
-use tracing_subscriber::EnvFilter;
+// use tracing_subscriber::EnvFilter;
 
 pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
     // let env_filter = EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("warn"));

src/parser/list.rs

@@ -64,16 +64,19 @@ impl<T> List<T> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn without_front(&self) -> List<T> {
         List {
             head: self.head.as_ref().map(|node| node.parent.clone()).flatten(),
         }
     }
 
+    #[allow(dead_code)]
     pub fn get_data(&self) -> Option<&T> {
         self.head.as_ref().map(|rc_node| &rc_node.data)
     }
 
+    #[allow(dead_code)]
     pub fn is_empty(&self) -> bool {
         self.head.is_none()
     }
@@ -92,6 +95,7 @@ impl<T> List<T> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn iter_until<'a>(&'a self, other: &'a List<T>) -> impl Iterator<Item = &Rc<Node<T>>> {
         NodeIterUntil {
             position: &self.head,
@@ -99,6 +103,7 @@ impl<T> List<T> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn into_iter_until<'a>(self, other: &'a List<T>) -> impl Iterator<Item = T> + 'a {
         NodeIntoIterUntil {
             position: self,

src/parser/parser_context.rs

@@ -28,6 +28,7 @@ impl<'r, 's> ContextTree<'r, 's> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn ptr_eq<'x, 'y>(&self, other: &ContextTree<'x, 'y>) -> bool {
         self.tree.ptr_eq(&other.tree)
     }
@@ -37,29 +38,10 @@ impl<'r, 's> ContextTree<'r, 's> {
         ContextTree { tree: new_list }
     }
 
-    pub fn pop_front(&mut self) -> (Option<ContextElement<'r, 's>>, ContextTree<'r, 's>) {
-        let (popped_element, remaining) = self.tree.pop_front();
-        (popped_element, ContextTree { tree: remaining })
-    }
-
     pub fn iter(&self) -> impl Iterator<Item = &Rc<Node<ContextElement<'r, 's>>>> {
         self.tree.iter()
     }
 
-    pub fn iter_until<'x: 'r>(
-        &'r self,
-        other: &'x ContextTree<'x, 's>,
-    ) -> impl Iterator<Item = &Rc<Node<ContextElement<'r, 's>>>> {
-        self.tree.iter_until(&other.tree)
-    }
-
-    pub fn into_iter_until<'x: 'r>(
-        self,
-        other: &'x ContextTree<'x, 's>,
-    ) -> impl Iterator<Item = ContextElement<'r, 's>> {
-        self.tree.into_iter_until(&other.tree)
-    }
-
     #[tracing::instrument(ret, level = "debug")]
     pub fn check_exit_matcher(
         &'r self,

src/parser/util.rs

@@ -22,6 +22,7 @@ pub const WORD_CONSTITUENT_CHARACTERS: &str =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 /// Check if we are below a section of the given section type regardless of depth
+#[allow(dead_code)]
 pub fn in_section<'r, 's, 'x>(context: Context<'r, 's>, section_name: &'x str) -> bool {
     for thing in context.iter() {
         match thing.get_data() {