Merge pull request #65 from gwenn/clippy

Clippy

benches/keyword.rs

@@ -146,7 +146,7 @@ static VALUES: [&[u8]; 136] = [
 #[bench]
 fn bench_keyword_token(b: &mut Bencher) {
  b.iter(|| {
- for value in VALUES.iter() {
+ for value in &VALUES {
  assert!(keyword_token(value).is_some())
  }
  });

examples/sql_tokens.rs

@@ -32,7 +32,7 @@ fn main() {
  //TK_ID => debug_assert!(),
  //TK_VARIABLE => debug_assert!(),
  TK_BLOB => debug_assert!(
- token.len() % 2 == 0 && token.iter().all(|b| b.is_ascii_hexdigit())
+ token.len() % 2 == 0 && token.iter().all(u8::is_ascii_hexdigit)
  ),
  TK_INTEGER => {
  if token.len() > 2
@@ -50,7 +50,7 @@ fn main() {
  if res.is_err() {
  eprintln!("Err: {} in {}", res.unwrap_err(), arg);
  }*/
- debug_assert!(token.iter().all(|b| b.is_ascii_digit()))
+ debug_assert!(token.iter().all(u8::is_ascii_digit))
  }
  }
  TK_FLOAT => {

src/dialect/mod.rs

@@ -48,7 +48,7 @@ pub(crate) const MAX_KEYWORD_LEN: usize = 17;
 pub fn keyword_token(word: &[u8]) -> Option<TokenType> {
  KEYWORDS
  .get(UncasedStr::new(unsafe { str::from_utf8_unchecked(word) }))
- .cloned()
+ .copied()
 }
 
 pub(crate) fn is_identifier(name: &str) -> bool {

src/lexer/scan.rs

@@ -60,8 +60,8 @@ pub struct Scanner<S: Splitter> {
 
 impl<S: Splitter> Scanner<S> {
  /// Constructor
- pub fn new(splitter: S) -> Scanner<S> {
- Scanner {
+ pub fn new(splitter: S) -> Self {
+ Self {
  offset: 0,
  mark: (0, 0, 0),
  splitter,

src/lexer/sql/error.rs

@@ -36,60 +36,60 @@ pub enum Error {
 impl fmt::Display for Error {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match *self {
- Error::Io(ref err) => err.fmt(f),
- Error::UnrecognizedToken(pos) => write!(f, "unrecognized token at {:?}", pos.unwrap()),
- Error::UnterminatedLiteral(pos) => {
+ Self::Io(ref err) => err.fmt(f),
+ Self::UnrecognizedToken(pos) => write!(f, "unrecognized token at {:?}", pos.unwrap()),
+ Self::UnterminatedLiteral(pos) => {
  write!(f, "non-terminated literal at {:?}", pos.unwrap())
  }
- Error::UnterminatedBracket(pos) => {
+ Self::UnterminatedBracket(pos) => {
  write!(f, "non-terminated bracket at {:?}", pos.unwrap())
  }
- Error::UnterminatedBlockComment(pos) => {
+ Self::UnterminatedBlockComment(pos) => {
  write!(f, "non-terminated block comment at {:?}", pos.unwrap())
  }
- Error::BadVariableName(pos) => write!(f, "bad variable name at {:?}", pos.unwrap()),
- Error::BadNumber(pos) => write!(f, "bad number at {:?}", pos.unwrap()),
- Error::ExpectedEqualsSign(pos) => write!(f, "expected = sign at {:?}", pos.unwrap()),
- Error::MalformedBlobLiteral(pos) => {
+ Self::BadVariableName(pos) => write!(f, "bad variable name at {:?}", pos.unwrap()),
+ Self::BadNumber(pos) => write!(f, "bad number at {:?}", pos.unwrap()),
+ Self::ExpectedEqualsSign(pos) => write!(f, "expected = sign at {:?}", pos.unwrap()),
+ Self::MalformedBlobLiteral(pos) => {
  write!(f, "malformed blob literal at {:?}", pos.unwrap())
  }
- Error::MalformedHexInteger(pos) => {
+ Self::MalformedHexInteger(pos) => {
  write!(f, "malformed hex integer at {:?}", pos.unwrap())
  }
- Error::ParserError(ref msg, Some(pos)) => write!(f, "{} at {:?}", msg, pos),
- Error::ParserError(ref msg, _) => write!(f, "{}", msg),
+ Self::ParserError(ref msg, Some(pos)) => write!(f, "{msg} at {pos:?}"),
+ Self::ParserError(ref msg, _) => write!(f, "{msg}"),
  }
  }
 }
 
 impl error::Error for Error {}
 
 impl From<io::Error> for Error {
- fn from(err: io::Error) -> Error {
- Error::Io(err)
+ fn from(err: io::Error) -> Self {
+ Self::Io(err)
  }
 }
 
 impl From<ParserError> for Error {
- fn from(err: ParserError) -> Error {
- Error::ParserError(err, None)
+ fn from(err: ParserError) -> Self {
+ Self::ParserError(err, None)
  }
 }
 
 impl ScanError for Error {
  fn position(&mut self, line: u64, column: usize) {
  match *self {
- Error::Io(_) => {}
- Error::UnrecognizedToken(ref mut pos) => *pos = Some((line, column)),
- Error::UnterminatedLiteral(ref mut pos) => *pos = Some((line, column)),
- Error::UnterminatedBracket(ref mut pos) => *pos = Some((line, column)),
- Error::UnterminatedBlockComment(ref mut pos) => *pos = Some((line, column)),
- Error::BadVariableName(ref mut pos) => *pos = Some((line, column)),
- Error::BadNumber(ref mut pos) => *pos = Some((line, column)),
- Error::ExpectedEqualsSign(ref mut pos) => *pos = Some((line, column)),
- Error::MalformedBlobLiteral(ref mut pos) => *pos = Some((line, column)),
- Error::MalformedHexInteger(ref mut pos) => *pos = Some((line, column)),
- Error::ParserError(_, ref mut pos) => *pos = Some((line, column)),
+ Self::Io(_) => {}
+ Self::UnrecognizedToken(ref mut pos) => *pos = Some((line, column)),
+ Self::UnterminatedLiteral(ref mut pos) => *pos = Some((line, column)),
+ Self::UnterminatedBracket(ref mut pos) => *pos = Some((line, column)),
+ Self::UnterminatedBlockComment(ref mut pos) => *pos = Some((line, column)),
+ Self::BadVariableName(ref mut pos) => *pos = Some((line, column)),
+ Self::BadNumber(ref mut pos) => *pos = Some((line, column)),
+ Self::ExpectedEqualsSign(ref mut pos) => *pos = Some((line, column)),
+ Self::MalformedBlobLiteral(ref mut pos) => *pos = Some((line, column)),
+ Self::MalformedHexInteger(ref mut pos) => *pos = Some((line, column)),
+ Self::ParserError(_, ref mut pos) => *pos = Some((line, column)),
  }
  }
 }

src/lexer/sql/mod.rs

@@ -33,7 +33,7 @@ pub struct Parser<'input> {
 
 impl<'input> Parser<'input> {
  /// Constructor
- pub fn new(input: &'input [u8]) -> Parser<'input> {
+ pub fn new(input: &'input [u8]) -> Self {
  let lexer = Tokenizer::new();
  let scanner = Scanner::new(lexer);
  let ctx = Context::new(input);
@@ -253,8 +253,8 @@ pub struct Tokenizer {}
 
 impl Tokenizer {
  /// Constructor
- pub fn new() -> Tokenizer {
- Tokenizer {}
+ pub fn new() -> Self {
+ Self {}
  }
 }
 
@@ -401,7 +401,7 @@ impl Splitter for Tokenizer {
  b',' => Ok((Some((&data[..1], TK_COMMA)), 1)),
  b'&' => Ok((Some((&data[..1], TK_BITAND)), 1)),
  b'~' => Ok((Some((&data[..1], TK_BITNOT)), 1)),
- quote @ b'`' | quote @ b'\'' | quote @ b'"' => literal(data, quote),
+ quote @ (b'`' | b'\'' | b'"') => literal(data, quote),
  b'.' => {
  if let Some(b) = data.get(1) {
  if b.is_ascii_digit() {
@@ -417,7 +417,7 @@ impl Splitter for Tokenizer {
  b'[' => {
  if let Some(i) = memchr(b']', data) {
  // Keep original quotes / '[' ... ’]'
- Ok((Some((&data[0..i + 1], TK_ID)), i + 1))
+ Ok((Some((&data[0..=i], TK_ID)), i + 1))
  } else {
  Err(Error::UnterminatedBracket(None))
  }

src/lexer/sql/test.rs

@@ -96,7 +96,7 @@ fn vtab_args() -> Result<(), Error> {
 #[test]
 fn only_semicolons_no_statements() {
  let sqls = ["", ";", ";;;"];
- for sql in sqls.iter() {
+ for sql in &sqls {
  let r = parse(sql.as_bytes());
  assert_eq!(r.unwrap(), None);
  }
@@ -110,7 +110,7 @@ fn extra_semicolons_between_statements() {
  "; SELECT 1; SELECT 2",
  ";; SELECT 1;; SELECT 2;;",
  ];
- for sql in sqls.iter() {
+ for sql in &sqls {
  let mut parser = Parser::new(sql.as_bytes());
  assert!(matches!(
  parser.next().unwrap(),
@@ -132,7 +132,7 @@ fn extra_comments_between_statements() {
  "/* abc */; SELECT 1 /* def */; SELECT 2 /* ghj */",
  "/* abc */;; SELECT 1;/* def */; SELECT 2; /* ghj */; /* klm */",
  ];
- for sql in sqls.iter() {
+ for sql in &sqls {
  let mut parser = Parser::new(sql.as_bytes());
  assert!(matches!(
  parser.next().unwrap(),