From 9107b3ddbe4a5f55c85f6eb3b6a828f98f6f4097 Mon Sep 17 00:00:00 2001 From: Skgland Date: Sat, 6 Feb 2021 19:45:21 +0100 Subject: [PATCH] fix some clippy lint warnings --- crates/prolog_parser/src/ast.rs | 76 +++++++++++++-------------- crates/prolog_parser/src/lexer.rs | 4 +- crates/prolog_parser/src/parser.rs | 47 ++++++++--------- crates/prolog_parser/src/tabled_rc.rs | 2 +- 4 files changed, 64 insertions(+), 65 deletions(-) diff --git a/crates/prolog_parser/src/ast.rs b/crates/prolog_parser/src/ast.rs index 5810b94c..6f05bcba 100644 --- a/crates/prolog_parser/src/ast.rs +++ b/crates/prolog_parser/src/ast.rs @@ -197,8 +197,8 @@ impl RegType { impl fmt::Display for RegType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - &RegType::Perm(val) => write!(f, "Y{}", val), - &RegType::Temp(val) => write!(f, "X{}", val), + RegType::Perm(val) => write!(f, "Y{}", val), + RegType::Temp(val) => write!(f, "X{}", val), } } } @@ -220,10 +220,10 @@ impl VarReg { impl fmt::Display for VarReg { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - &VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg), - &VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg), - &VarReg::ArgAndNorm(RegType::Perm(reg), arg) => write!(f, "Y{} A{}", reg, arg), - &VarReg::ArgAndNorm(RegType::Temp(reg), arg) => write!(f, "X{} A{}", reg, arg), + VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg), + VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg), + VarReg::ArgAndNorm(RegType::Perm(reg), arg) => write!(f, "Y{} A{}", reg, arg), + VarReg::ArgAndNorm(RegType::Temp(reg), arg) => write!(f, "X{} A{}", reg, arg), } } } @@ -382,16 +382,16 @@ impl ParserError { pub fn as_str(&self) -> &'static str { match self { - &ParserError::BackQuotedString(..) => "back_quoted_string", - &ParserError::UnexpectedChar(..) => "unexpected_char", - &ParserError::UnexpectedEOF => "unexpected_end_of_file", - &ParserError::IncompleteReduction(..) => "incomplete_reduction", - &ParserError::InvalidSingleQuotedCharacter(..) => "invalid_single_quoted_character", - &ParserError::IO(_) => "input_output_error", - &ParserError::MissingQuote(..) => "missing_quote", - &ParserError::NonPrologChar(..) => "non_prolog_character", - &ParserError::ParseBigInt(..) => "cannot_parse_big_int", - &ParserError::Utf8Error(..) => "utf8_conversion_error", + ParserError::BackQuotedString(..) => "back_quoted_string", + ParserError::UnexpectedChar(..) => "unexpected_char", + ParserError::UnexpectedEOF => "unexpected_end_of_file", + ParserError::IncompleteReduction(..) => "incomplete_reduction", + ParserError::InvalidSingleQuotedCharacter(..) => "invalid_single_quoted_character", + ParserError::IO(_) => "input_output_error", + ParserError::MissingQuote(..) => "missing_quote", + ParserError::NonPrologChar(..) => "non_prolog_character", + ParserError::ParseBigInt(..) => "cannot_parse_big_int", + ParserError::Utf8Error(..) => "utf8_conversion_error", } } } @@ -525,21 +525,21 @@ pub enum Constant { impl fmt::Display for Constant { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - &Constant::Atom(ref atom, _) => { + Constant::Atom(ref atom, _) => { if atom.as_str().chars().any(|c| "`.$'\" ".contains(c)) { write!(f, "'{}'", atom.as_str()) } else { write!(f, "{}", atom.as_str()) } } - &Constant::Char(c) => write!(f, "'{}'", c as u32), - &Constant::EmptyList => write!(f, "[]"), - &Constant::Fixnum(n) => write!(f, "{}", n), - &Constant::Integer(ref n) => write!(f, "{}", n), - &Constant::Rational(ref n) => write!(f, "{}", n), - &Constant::Float(ref n) => write!(f, "{}", n), - &Constant::String(ref s) => write!(f, "\"{}\"", &s), - &Constant::Usize(integer) => write!(f, "u{}", integer), + Constant::Char(c) => write!(f, "'{}'", *c as u32), + Constant::EmptyList => write!(f, "[]"), + Constant::Fixnum(n) => write!(f, "{}", n), + Constant::Integer(ref n) => write!(f, "{}", n), + Constant::Rational(ref n) => write!(f, "{}", n), + Constant::Float(ref n) => write!(f, "{}", n), + Constant::String(ref s) => write!(f, "\"{}\"", &s), + Constant::Usize(integer) => write!(f, "u{}", integer), } } } @@ -549,7 +549,7 @@ impl PartialEq for Constant { match (self, other) { (&Constant::Atom(ref atom, _), &Constant::Char(c)) | (&Constant::Char(c), &Constant::Atom(ref atom, _)) => { - atom.is_char() && Some(c) == atom.as_str().chars().next() + atom.is_char() && atom.as_str().starts_with(c) } (&Constant::Atom(ref a1, _), &Constant::Atom(ref a2, _)) => a1.as_str() == a2.as_str(), (&Constant::Char(c1), &Constant::Char(c2)) => c1 == c2, @@ -565,7 +565,7 @@ impl PartialEq for Constant { (&Constant::Integer(ref n1), &Constant::Integer(ref n2)) => n1 == n2, (&Constant::Rational(ref n1), &Constant::Rational(ref n2)) => n1 == n2, (&Constant::Float(ref n1), &Constant::Float(ref n2)) => n1 == n2, - (&Constant::String(ref s1), &Constant::String(ref s2)) => &s1 == &s2, + (&Constant::String(ref s1), &Constant::String(ref s2)) => s1 == s2, (&Constant::EmptyList, &Constant::EmptyList) => true, (&Constant::Usize(u1), &Constant::Usize(u2)) => u1 == u2, _ => false, @@ -632,7 +632,7 @@ impl ClauseName { #[inline] pub fn owning_module(&self) -> Self { match self { - &ClauseName::User(ref name) => { + ClauseName::User(ref name) => { let module = name.owning_module(); ClauseName::User(TabledRc { atom: module.clone(), @@ -646,8 +646,8 @@ impl ClauseName { #[inline] pub fn to_rc(&self) -> Rc { match self { - &ClauseName::BuiltIn(s) => Rc::new(s.to_string()), - &ClauseName::User(ref rc) => rc.inner(), + ClauseName::BuiltIn(s) => Rc::new(s.to_string()), + ClauseName::User(ref rc) => rc.inner(), } } @@ -687,14 +687,14 @@ impl ClauseName { #[inline] pub fn as_str(&self) -> &str { match self { - &ClauseName::BuiltIn(s) => s, - &ClauseName::User(ref name) => name.as_ref(), + ClauseName::BuiltIn(s) => s, + ClauseName::User(ref name) => name.as_ref(), } } #[inline] pub fn is_char(&self) -> bool { - !self.as_str().is_empty() && self.as_str().chars().skip(1).next().is_none() + !self.as_str().is_empty() && self.as_str().chars().nth(1).is_none() } pub fn defrock_brackets(self) -> Self { @@ -739,8 +739,8 @@ pub enum Term { impl Term { pub fn shared_op_desc(&self) -> Option { match self { - &Term::Clause(_, _, _, ref spec) => spec.clone(), - &Term::Constant(_, Constant::Atom(_, ref spec)) => spec.clone(), + Term::Clause(_, _, _, ref spec) => spec.clone(), + Term::Constant(_, Constant::Atom(_, ref spec)) => spec.clone(), _ => None, } } @@ -754,7 +754,7 @@ impl Term { pub fn first_arg(&self) -> Option<&Term> { match self { - &Term::Clause(_, _, ref terms, _) => terms.first().map(|bt| bt.as_ref()), + Term::Clause(_, _, ref terms, _) => terms.first().map(|bt| bt.as_ref()), _ => None, } } @@ -780,14 +780,14 @@ impl Term { pub fn arity(&self) -> usize { match self { - &Term::Clause(_, _, ref child_terms, ..) => child_terms.len(), + Term::Clause(_, _, ref child_terms, ..) => child_terms.len(), _ => 0, } } } fn unfold_by_str_once(term: &mut Term, s: &str) -> Option<(Term, Term)> { - if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term { + if let Term::Clause(_, ref name, ref mut subterms, _) = term { if name.as_str() == s && subterms.len() == 2 { let snd = *subterms.pop().unwrap(); let fst = *subterms.pop().unwrap(); diff --git a/crates/prolog_parser/src/lexer.rs b/crates/prolog_parser/src/lexer.rs index aff75d23..75a3a91e 100644 --- a/crates/prolog_parser/src/lexer.rs +++ b/crates/prolog_parser/src/lexer.rs @@ -517,7 +517,7 @@ impl<'a, R: Read> Lexer<'a, R> { if single_quote_char!(self.lookahead_char()?) { self.skip_char()?; - if !token.is_empty() && token.chars().skip(1).next().is_none() { + if !token.is_empty() && token.chars().nth(1).is_none() { if let Some(c) = token.chars().next() { return Ok(Token::Constant(Constant::Char(c))); } @@ -713,7 +713,7 @@ impl<'a, R: Read> Lexer<'a, R> { } self.get_single_quoted_char() - .and_then(|c| Ok(Token::Constant(Constant::Fixnum(c as isize)))) + .map(|c| Token::Constant(Constant::Fixnum(c as isize))) .or_else(|_| { self.return_char(c); diff --git a/crates/prolog_parser/src/parser.rs b/crates/prolog_parser/src/parser.rs index 87785daa..4ff09eb6 100644 --- a/crates/prolog_parser/src/parser.rs +++ b/crates/prolog_parser/src/parser.rs @@ -484,7 +484,7 @@ impl<'a, R: Read> Parser<'a, R> { if self.atomize_term(&self.terms[idx - 1]).is_some() { self.stack.truncate(stack_len + 1); - let mut subterms: Vec<_> = self.terms.drain(idx..).map(|t| Box::new(t)).collect(); + let mut subterms: Vec<_> = self.terms.drain(idx..).map(Box::new).collect(); if let Some(name) = self.terms.pop().and_then(|t| self.atomize_term(&t)) { // reduce the '.' functor to a cons cell if it applies. @@ -722,25 +722,24 @@ impl<'a, R: Read> Parser<'a, R> { let idx = self.stack.len() - 2; - match self.stack.remove(idx) { - td => match td.tt { - TokenType::Open | TokenType::OpenCT => { - if self.stack[idx].tt == TokenType::Comma { - return false; - } - - if let Some(atom) = sep_to_atom(self.stack[idx].tt) { - self.terms - .push(Term::Constant(Cell::default(), Constant::Atom(atom, None))); - } + let td = self.stack.remove(idx); + match td.tt { + TokenType::Open | TokenType::OpenCT => { + if self.stack[idx].tt == TokenType::Comma { + return false; + } - self.stack[idx].spec = TERM; - self.stack[idx].tt = TokenType::Term; - self.stack[idx].priority = 0; - true + if let Some(atom) = sep_to_atom(self.stack[idx].tt) { + self.terms + .push(Term::Constant(Cell::default(), Constant::Atom(atom, None))); } - _ => false, - }, + + self.stack[idx].spec = TERM; + self.stack[idx].tt = TokenType::Term; + self.stack[idx].priority = 0; + true + } + _ => false, } } @@ -756,7 +755,7 @@ impl<'a, R: Read> Parser<'a, R> { match self.tokens.last().ok_or(ParserError::UnexpectedEOF)? { // do this when layout hasn't been inserted, // ie. why we don't match on Token::Open. - &Token::OpenCT => { + Token::OpenCT => { // can't be prefix, so either inf == 0 // or post == 0. self.reduce_op(inf + post); @@ -831,16 +830,16 @@ impl<'a, R: Read> Parser<'a, R> { fn atomize_term(&self, term: &Term) -> Option { match term { - &Term::Constant(_, ref c) => self.atomize_constant(c), + Term::Constant(_, ref c) => self.atomize_constant(c), _ => None, } } fn atomize_constant(&self, c: &Constant) -> Option { match c { - &Constant::Atom(ref name, _) => Some(name.clone()), - &Constant::Char(c) => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)), - &Constant::EmptyList => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)), + Constant::Atom(ref name, _) => Some(name.clone()), + Constant::Char(c) => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)), + Constant::EmptyList => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)), _ => None, } } @@ -892,7 +891,7 @@ impl<'a, R: Read> Parser<'a, R> { self.negate_number(n, negate_rc, Constant::Rational) } Token::Constant(Constant::Float(n)) => { - self.negate_number(n, |n| OrderedFloat(-n.into_inner()), |n| Constant::Float(n)) + self.negate_number(n, |n| OrderedFloat(-n.into_inner()), Constant::Float) } Token::Constant(c) => { if let Some(name) = self.atomize_constant(&c) { diff --git a/crates/prolog_parser/src/tabled_rc.rs b/crates/prolog_parser/src/tabled_rc.rs index 8fcf4b86..47f87d30 100644 --- a/crates/prolog_parser/src/tabled_rc.rs +++ b/crates/prolog_parser/src/tabled_rc.rs @@ -104,7 +104,7 @@ impl Hash for TabledRc { impl TabledRc { pub fn new(atom: T, table: TabledData) -> Self { let atom = match table.borrow_mut().take(&atom) { - Some(atom) => atom.clone(), + Some(atom) => atom, None => Rc::new(atom), }; -- 2.54.0