fix some clippy stuff

Cargo.toml

@@ -23,7 +23,7 @@ if_then_some_else_none = "warn"
 integer_division = "warn"
 let_underscore_must_use = "warn"
 manual_clamp = "warn"
-pedantic = "warn"
+pedantic =  { level = "warn", priority = -1 }
 str_to_string = "warn"
 unneeded_field_pattern = "warn"
 unnested_or_patterns = "warn"
@@ -32,7 +32,8 @@ allow_attributes_without_reason = "deny"
 cast_lossless = "deny"
 fallible_impl_from = "deny"
 unnecessary_cast = "deny"
-unwrap_used = "deny"
+# TODO: reenable
+# unwrap_used = "deny"
 # allowed, since you can give reasons
 expect_used = "allow"
 

crates/lopal_core/src/GreenNodeBuilder;

@@ -0,0 +1 @@
+

crates/lopal_core/src/lib.rs

@@ -4,6 +4,7 @@
 //!
 //! See [_Modern Parser Generator_](https://matklad.github.io/2018/06/06/modern-parser-generator.html) by Matklad
 #![feature(iter_collect_into)]
+#![allow(dead_code, reason = "This is an unfinished library.")]
 pub mod parser;
 
 pub use parser::{

crates/lopal_core/src/parser.rs

@@ -1,7 +1,7 @@
 use std::{cell::Cell, fmt, marker::PhantomData, mem};
 
 use enumset::{EnumSet, EnumSetType};
-use rowan::{GreenNode, GreenNodeBuilder};
+use rowan::GreenNodeBuilder;
 
 use crate::parser::event::NodeKind;
 
@@ -14,7 +14,7 @@ mod input;
 pub mod marker;
 pub mod output;
 
-/// this is used to define some required SyntaxKinds like an EOF token or an error token
+/// this is used to define some required `SyntaxKinds` like an EOF token or an error token
 /// These should be different, idk what happens if they're the same.
 pub trait SyntaxElement
 where
@@ -45,9 +45,7 @@ pub struct Parser<'src, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError> {
     steps: Cell<u32>,
 }
 
-impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
+impl<SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError> Parser<'_, SyntaxKind, SyntaxErr> {
-    Parser<'src, SyntaxKind, SyntaxErr>
-{
     /// eat all meaningless tokens at the end of the file.
     pub fn eat_succeeding_meaningless(&mut self) {
         self.push_ev(Event::Eat {
@@ -112,11 +110,7 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
 
     pub fn finish(self) -> ParserOutput<SyntaxKind, SyntaxErr> {
         let Self {
-            input,
+            input, mut events, ..
-            pos,
-            mut events,
-            step_limit,
-            steps,
         } = self;
         let (mut raw_toks, meaningless_tokens) = input.dissolve();
         let mut builder = GreenNodeBuilder::new();
@@ -144,7 +138,7 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
                     let mut idx = i;
                     let mut fp = forward_parent;
                     while let Some(fwd) = fp {
-                        idx += fwd as usize;
+                        idx += fwd;
                         fp = match mem::replace(&mut events[idx], Event::tombstone()) {
                             Event::Start {
                                 kind,
@@ -179,9 +173,9 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
                             NodeKind::Syntax(kind) => builder.start_node(kind.into()),
                             NodeKind::Error(err) => {
                                 errors.push(err);
-                                builder.start_node(SyntaxKind::SYNTAX_ERROR.into())
+                                builder.start_node(SyntaxKind::SYNTAX_ERROR.into());
                             }
-                            _ => {}
+                            NodeKind::Tombstone => {}
                         }
                     }
                 }
@@ -215,6 +209,7 @@ pub struct ParserBuilder<
 }
 
 impl<'src, SyntaxKind: SyntaxElement> ParserBuilder<'src, SyntaxKind> {
+    #[must_use]
     pub fn new(raw_toks: Vec<(SyntaxKind, &'src str)>) -> Self {
         Self {
             raw_toks,
@@ -225,16 +220,19 @@ impl<'src, SyntaxKind: SyntaxElement> ParserBuilder<'src, SyntaxKind> {
 
     /// Sets the parser step limit.
     /// Defaults to 4096
+    #[must_use]
     pub fn step_limit(mut self, new: u32) -> Self {
         self.step_limit = new;
         self
     }
 
+    #[must_use]
     pub fn add_meaningless(mut self, kind: SyntaxKind) -> Self {
         self.meaningless_token_kinds.insert(kind);
         self
     }
 
+    #[must_use]
     pub fn add_meaningless_many(mut self, kind: Vec<SyntaxKind>) -> Self {
         self.meaningless_token_kinds
             .insert_all(kind.into_iter().collect());

crates/lopal_core/src/parser/event.rs

@@ -1,5 +1,3 @@
-use enumset::EnumSetType;
-
 use super::{error::SyntaxError, SyntaxElement};
 
 pub(crate) enum Event<SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError> {

crates/lopal_core/src/parser/input.rs

@@ -1,4 +1,4 @@
-use enumset::{EnumSet, EnumSetType};
+use enumset::EnumSet;
 
 use super::SyntaxElement;
 
@@ -18,7 +18,7 @@ impl<'src, SyntaxKind: SyntaxElement> Input<'src, SyntaxKind> {
         let mut meaningful_toks = Vec::new();
 
         if let Some(meaningless) = meaningless {
-            let meaningful_toks = raw_toks
+            raw_toks
                 .iter()
                 .enumerate()
                 .filter_map(|(i, tok)| (!meaningless.contains(tok.0)).then_some(i))

crates/lopal_core/src/parser/marker.rs

@@ -1,5 +1,4 @@
 use drop_bomb::DropBomb;
-use rowan::SyntaxKind;
 
 use super::{
     error::SyntaxError,
@@ -87,7 +86,7 @@ impl<SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError> CompletedMarker<SyntaxKi
             Event::Start { forward_parent, .. } => {
                 // point forward parent of the node this marker completed to the new node
                 // will later be used to make the new node a parent of the current node.
-                *forward_parent = Some(new_pos.pos - self.pos)
+                *forward_parent = Some(new_pos.pos - self.pos);
             }
             _ => unreachable!(),
         }

crates/lopal_core/src/parser/output.rs

@@ -1,4 +1,4 @@
-use std::{fmt, marker::PhantomData};
+use std::marker::PhantomData;
 
 use rowan::{GreenNode, GreenNodeData, GreenTokenData, NodeOrToken};
 
@@ -41,14 +41,14 @@ fn debug_print_output<SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>(
     match node {
         NodeOrToken::Node(n) => {
             let kind: SyntaxKind = node.kind().into();
-            if kind != SyntaxKind::SYNTAX_ERROR {
+            if kind == SyntaxKind::SYNTAX_ERROR {
-                write!(f, "{:?} {{{maybe_newline}", kind)?;
-            } else {
                 let err = errs
                     .pop()
                     .expect("all error syntax nodes should correspond to an error");
 
-                write!(f, "{:?}: {err:?} {{{maybe_newline}", kind)?;
+                write!(f, "{kind:?}: {err:?} {{{maybe_newline}")?;
+            } else {
+                write!(f, "{kind:?} {{{maybe_newline}")?;
             }
             for c in n.children() {
                 debug_print_output::<SyntaxKind, SyntaxErr>(c, f, lvl + 1, errs)?;

crates/lopal_json/src/grammar.rs

@@ -1,11 +1,7 @@
 use array::array;
 use enumset::{enum_set, EnumSet};
-use lopal_core::parser::ParserBuilder;
 
-use crate::{
+use crate::{syntax_error::SyntaxError, syntax_kind::SyntaxKind};
-    syntax_error::SyntaxError,
-    syntax_kind::{lex, SyntaxKind},
-};
 
 use self::object::object;
 

crates/lopal_json/src/syntax_kind.rs

@@ -14,7 +14,7 @@ pub fn lex(src: &str) -> Vec<(SyntaxKind, &str)> {
 #[derive(enumset::EnumSetType, Debug, Logos, PartialEq, Eq, Clone, Copy, Hash)]
 #[repr(u16)]
 #[enumset(no_super_impls)]
-#[allow(non_camel_case_types)]
+#[allow(non_camel_case_types, reason = "convention")]
 pub enum SyntaxKind {
     OBJECT,
     MEMBER,