clippy / rustfmt

Author: coord-e

src/annot.rs

@@ -235,25 +235,21 @@ where
         let (term, sort) = self.parse_atom_term()?;
 
         let mut fields = Vec::new();
-        loop {
-            if let Some(Token {
-                kind: TokenKind::Dot,
-                ..
-            }) = self.look_ahead_token(0)
-            {
-                self.consume();
-                match self.next_token("field")? {
-                    Token {
-                        kind: TokenKind::Literal(lit),
-                        ..
-                    } if matches!(lit.kind, LitKind::Integer) => {
-                        let idx = lit.symbol.as_str().parse().unwrap();
-                        fields.push(idx);
-                    }
-                    t => return Err(ParseAttrError::unexpected_token("field", t.clone())),
+        while let Some(Token {
+            kind: TokenKind::Dot,
+            ..
+        }) = self.look_ahead_token(0)
+        {
+            self.consume();
+            match self.next_token("field")? {
+                Token {
+                    kind: TokenKind::Literal(lit),
+                    ..
+                } if matches!(lit.kind, LitKind::Integer) => {
+                    let idx = lit.symbol.as_str().parse().unwrap();
+                    fields.push(idx);
                 }
-            } else {
-                break;
+                t => return Err(ParseAttrError::unexpected_token("field", t.clone())),
             }
         }
 
@@ -428,36 +424,28 @@ where
 
     fn parse_formula_and(&mut self) -> Result<chc::Formula<T::Output>> {
         let mut formula = self.parse_formula_atom()?;
-        loop {
-            match self.look_ahead_token(0) {
-                Some(Token {
-                    kind: TokenKind::AndAnd,
-                    ..
-                }) => {
-                    self.consume();
-                    let next_formula = self.parse_formula_atom()?;
-                    formula = formula.and(next_formula);
-                }
-                _ => break,
-            }
+        while let Some(Token {
+            kind: TokenKind::AndAnd,
+            ..
+        }) = self.look_ahead_token(0)
+        {
+            self.consume();
+            let next_formula = self.parse_formula_atom()?;
+            formula = formula.and(next_formula);
         }
         Ok(formula)
     }
 
     fn parse_formula(&mut self) -> Result<chc::Formula<T::Output>> {
         let mut formula = self.parse_formula_and()?;
-        loop {
-            match self.look_ahead_token(0) {
-                Some(Token {
-                    kind: TokenKind::OrOr,
-                    ..
-                }) => {
-                    self.consume();
-                    let next_formula = self.parse_formula_and()?;
-                    formula = formula.or(next_formula);
-                }
-                _ => break,
-            }
+        while let Some(Token {
+            kind: TokenKind::OrOr,
+            ..
+        }) = self.look_ahead_token(0)
+        {
+            self.consume();
+            let next_formula = self.parse_formula_and()?;
+            formula = formula.or(next_formula);
         }
         Ok(formula)
     }

src/chc/clause_builder.rs

@@ -99,24 +99,28 @@ impl ClauseBuilder {
         self
     }
 
+    /*
     pub fn add_body_mapped<T>(&mut self, atom: Atom<T>) -> &mut Self
     where
         T: Var + Debug,
     {
         self.add_body(atom.map_var(|v| self.mapped_var(v)))
     }
+    */
 
     pub fn add_body_formula(&mut self, formula: Formula<TermVarIdx>) -> &mut Self {
         self.body_formula.push_conj(formula);
         self
     }
 
+    /*
     pub fn add_body_formula_mapped<T>(&mut self, formula: Formula<T>) -> &mut Self
     where
         T: Var + Debug,
     {
         self.add_body_formula(formula.map_var(|v| self.mapped_var(v)))
     }
+     */
 
     pub fn head(&self, head: Atom<TermVarIdx>) -> Clause {
         let vars = self.vars.clone();
@@ -142,10 +146,12 @@ impl ClauseBuilder {
         }
     }
 
+    /*
     pub fn head_mapped<T>(&self, head: Atom<T>) -> Clause
     where
         T: Var + Debug,
     {
         self.head(head.map_var(|v| self.mapped_var(v)))
     }
+     */
 }