Check clippy in CI

Author: Jules-Bertholet

.github/workflows/rust.yml

@@ -7,27 +7,30 @@ on:
  branches: [ master ]
 
 env:
+ CARGO_INCREMENTAL: 0
  CARGO_TERM_COLOR: always
+ RUST_BACKTRACE: 1
+ RUSTFLAGS: -D warnings
+ RUSTDOCFLAGS: -D warnings
 
 jobs:
  build:
-
  runs-on: ubuntu-latest
-
  steps:
  - uses: actions/checkout@v2
  - name: Build
  run: cargo build --verbose
  - name: Run tests
  run: cargo test --verbose
- fmt:
+ - name: Run clippy
+ run: cargo clippy --all-targets --all --verbose
 
+ fmt:
  runs-on: ubuntu-latest
-
  steps:
  - uses: actions/checkout@v2
  - name: Rustfmt
- run: cargo fmt --check
+ run: cargo fmt --all --check
  - name: Verify regenerated files
  run: ./scripts/unicode.py && diff tables.rs src/tables.rs
  - name: Verify regenerated tests

benches/chars.rs

@@ -6,7 +6,6 @@
 //! is how much slower full unicode handling is.
 
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use unicode_segmentation;
 
 use std::fs;
 use unicode_segmentation::UnicodeSegmentation;
@@ -24,14 +23,14 @@ const FILES: &[&str] = &[
 
 #[inline(always)]
 fn grapheme(text: &str) {
- for c in UnicodeSegmentation::graphemes(black_box(&*text), true) {
+ for c in UnicodeSegmentation::graphemes(black_box(text), true) {
  black_box(c);
  }
 }
 
 #[inline(always)]
 fn scalar(text: &str) {
- for c in black_box(&*text).chars() {
+ for c in black_box(text).chars() {
  black_box(c);
  }
 }

scripts/unicode_gen_breaktests.py

@@ -169,8 +169,8 @@ def create_grapheme_data(f):
  else:
  test_diff.append((allchars, extgraphs, c))
 
- stype = "&'static [(&'static str, &'static [&'static str])]"
- dtype = "&'static [(&'static str, &'static [&'static str], &'static [&'static str])]"
+ stype = "&[(&str, &[&str])]"
+ dtype = "&[(&str, &[&str], &[&str])]"
  f.write(" // official Unicode test data\n")
  f.write(" // http://www.unicode.org/Public/%s/ucd/auxiliary/GraphemeBreakTest.txt\n" % unicode.UNICODE_VERSION_NUMBER)
  unicode.emit_table(f, "TEST_SAME", test_same, stype, True, showfun, True)
@@ -185,7 +185,7 @@ def create_words_data(f):
  allchars = [cn for s in c for cn in s]
  test.append((allchars, c))
 
- wtype = "&'static [(&'static str, &'static [&'static str])]"
+ wtype = "&[(&str, &[&str])]"
  f.write(" // official Unicode test data\n")
  f.write(" // http://www.unicode.org/Public/%s/ucd/auxiliary/WordBreakTest.txt\n" % unicode.UNICODE_VERSION_NUMBER)
  unicode.emit_table(f, "TEST_WORD", test, wtype, True, showfun, True)
@@ -199,7 +199,7 @@ def create_sentence_data(f):
  allchars = [cn for s in c for cn in s]
  test.append((allchars, c))
 
- wtype = "&'static [(&'static str, &'static [&'static str])]"
+ wtype = "&[(&str, &[&str])]"
  f.write(" // official Unicode test data\n")
  f.write(" // http://www.unicode.org/Public/%s/ucd/auxiliary/SentenceBreakTest.txt\n" % unicode.UNICODE_VERSION_NUMBER)
  unicode.emit_table(f, "TEST_SENTENCE", test, wtype, True, showfun, True)

src/grapheme.rs

@@ -140,7 +140,7 @@ impl<'a> DoubleEndedIterator for Graphemes<'a> {
 }
 
 #[inline]
-pub fn new_graphemes<'b>(s: &'b str, is_extended: bool) -> Graphemes<'b> {
+pub fn new_graphemes(s: &str, is_extended: bool) -> Graphemes<'_> {
  let len = s.len();
  Graphemes {
  string: s,
@@ -150,7 +150,7 @@ pub fn new_graphemes<'b>(s: &'b str, is_extended: bool) -> Graphemes<'b> {
 }
 
 #[inline]
-pub fn new_grapheme_indices<'b>(s: &'b str, is_extended: bool) -> GraphemeIndices<'b> {
+pub fn new_grapheme_indices(s: &str, is_extended: bool) -> GraphemeIndices<'_> {
  GraphemeIndices {
  start_offset: s.as_ptr() as usize,
  iter: new_graphemes(s, is_extended),
@@ -296,10 +296,10 @@ impl GraphemeCursor {
  GraphemeState::Unknown
  };
  GraphemeCursor {
- offset: offset,
- len: len,
- state: state,
- is_extended: is_extended,
+ offset,
+ len,
+ state,
+ is_extended,
  cat_before: None,
  cat_after: None,
  pre_context_offset: None,
@@ -406,7 +406,7 @@ impl GraphemeCursor {
  assert!(chunk_start + chunk.len() == self.pre_context_offset.unwrap());
  self.pre_context_offset = None;
  if self.is_extended && chunk_start + chunk.len() == self.offset {
- let ch = chunk.chars().rev().next().unwrap();
+ let ch = chunk.chars().next_back().unwrap();
  if self.grapheme_category(ch) == gr::GC_Prepend {
  self.decide(false); // GB9b
  return;
@@ -417,7 +417,7 @@ impl GraphemeCursor {
  GraphemeState::Emoji => self.handle_emoji(chunk, chunk_start),
  _ => {
  if self.cat_before.is_none() && self.offset == chunk.len() + chunk_start {
- let ch = chunk.chars().rev().next().unwrap();
+ let ch = chunk.chars().next_back().unwrap();
  self.cat_before = Some(self.grapheme_category(ch));
  }
  }
@@ -540,10 +540,10 @@ impl GraphemeCursor {
  if self.state == GraphemeState::NotBreak {
  return Ok(false);
  }
- if self.offset < chunk_start || self.offset >= chunk_start + chunk.len() {
- if self.offset > chunk_start + chunk.len() || self.cat_after.is_none() {
-  return Err(GraphemeIncomplete::InvalidOffset);
- }
+ if (self.offset < chunk_start || self.offset >= chunk_start + chunk.len())
+ && (self.offset > chunk_start + chunk.len() || self.cat_after.is_none())
+ {
+ return Err(GraphemeIncomplete::InvalidOffset);
  }
  if let Some(pre_context_offset) = self.pre_context_offset {
  return Err(GraphemeIncomplete::PreContext(pre_context_offset));
@@ -566,15 +566,15 @@ impl GraphemeCursor {
  }
  }
  if self.cat_before.is_none() {
- let ch = chunk[..offset_in_chunk].chars().rev().next().unwrap();
+ let ch = chunk[..offset_in_chunk].chars().next_back().unwrap();
  self.cat_before = Some(self.grapheme_category(ch));
  }
  match check_pair(self.cat_before.unwrap(), self.cat_after.unwrap()) {
- PairResult::NotBreak => return self.decision(false),
- PairResult::Break => return self.decision(true),
+ PairResult::NotBreak => self.decision(false),
+ PairResult::Break => self.decision(true),
  PairResult::Extended => {
  let is_extended = self.is_extended;
- return self.decision(!is_extended);
+ self.decision(!is_extended)
  }
  PairResult::Regional => {
  if let Some(ris_count) = self.ris_count {

src/lib.rs

@@ -96,7 +96,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&gr2[..], b);
  /// ```
- fn graphemes<'a>(&'a self, is_extended: bool) -> Graphemes<'a>;
+ fn graphemes(&self, is_extended: bool) -> Graphemes<'_>;
 
  /// Returns an iterator over the grapheme clusters of `self` and their
  /// byte offsets. See `graphemes()` for more information.
@@ -111,7 +111,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&gr_inds[..], b);
  /// ```
- fn grapheme_indices<'a>(&'a self, is_extended: bool) -> GraphemeIndices<'a>;
+ fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices<'_>;
 
  /// Returns an iterator over the words of `self`, separated on
  /// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries).
@@ -133,7 +133,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&uw1[..], b);
  /// ```
- fn unicode_words<'a>(&'a self) -> UnicodeWords<'a>;
+ fn unicode_words(&self) -> UnicodeWords<'_>;
 
  /// Returns an iterator over the words of `self`, separated on
  /// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries), and their
@@ -157,7 +157,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&uwi1[..], b);
  /// ```
- fn unicode_word_indices<'a>(&'a self) -> UnicodeWordIndices<'a>;
+ fn unicode_word_indices(&self) -> UnicodeWordIndices<'_>;
 
  /// Returns an iterator over substrings of `self` separated on
  /// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries).
@@ -173,7 +173,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&swu1[..], b);
  /// ```
- fn split_word_bounds<'a>(&'a self) -> UWordBounds<'a>;
+ fn split_word_bounds(&self) -> UWordBounds<'_>;
 
  /// Returns an iterator over substrings of `self`, split on UAX#29 word boundaries,
  /// and their offsets. See `split_word_bounds()` for more information.
@@ -188,7 +188,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&swi1[..], b);
  /// ```
- fn split_word_bound_indices<'a>(&'a self) -> UWordBoundIndices<'a>;
+ fn split_word_bound_indices(&self) -> UWordBoundIndices<'_>;
 
  /// Returns an iterator over substrings of `self` separated on
  /// [UAX#29 sentence boundaries](http://www.unicode.org/reports/tr29/#Sentence_Boundaries).
@@ -210,7 +210,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&us1[..], b);
  /// ```
- fn unicode_sentences<'a>(&'a self) -> UnicodeSentences<'a>;
+ fn unicode_sentences(&self) -> UnicodeSentences<'_>;
 
  /// Returns an iterator over substrings of `self` separated on
  /// [UAX#29 sentence boundaries](http://www.unicode.org/reports/tr29/#Sentence_Boundaries).
@@ -227,7 +227,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&ssb1[..], b);
  /// ```
- fn split_sentence_bounds<'a>(&'a self) -> USentenceBounds<'a>;
+ fn split_sentence_bounds(&self) -> USentenceBounds<'_>;
 
  /// Returns an iterator over substrings of `self`, split on UAX#29 sentence boundaries,
  /// and their offsets. See `split_sentence_bounds()` for more information.
@@ -243,7 +243,7 @@ pub trait UnicodeSegmentation {
  ///
  /// assert_eq!(&ssi1[..], b);
  /// ```
- fn split_sentence_bound_indices<'a>(&'a self) -> USentenceBoundIndices<'a>;
+ fn split_sentence_bound_indices(&self) -> USentenceBoundIndices<'_>;
 }
 
 impl UnicodeSegmentation for str {

src/sentence.rs

@@ -264,9 +264,7 @@ mod fwd {
  }
 
  // SB2 https://unicode.org/reports/tr29/#SB2
- if self.state.match1(StatePart::Sot) {
- None
- } else if self.state.match1(StatePart::Eot) {
+ if self.state.match1(StatePart::Sot) || self.state.match1(StatePart::Eot) {
  None
  } else {
  self.state = self.state.end();
@@ -275,7 +273,7 @@ mod fwd {
  }
  }
 
- pub fn new_sentence_breaks<'a>(source: &'a str) -> SentenceBreaks<'a> {
+ pub fn new_sentence_breaks(source: &str) -> SentenceBreaks<'_> {
  SentenceBreaks {
  string: source,
  pos: 0,
@@ -329,28 +327,28 @@ pub struct USentenceBoundIndices<'a> {
 }
 
 #[inline]
-pub fn new_sentence_bounds<'a>(source: &'a str) -> USentenceBounds<'a> {
+pub fn new_sentence_bounds(source: &str) -> USentenceBounds<'_> {
  USentenceBounds {
  iter: fwd::new_sentence_breaks(source),
  sentence_start: None,
  }
 }
 
 #[inline]
-pub fn new_sentence_bound_indices<'a>(source: &'a str) -> USentenceBoundIndices<'a> {
+pub fn new_sentence_bound_indices(source: &str) -> USentenceBoundIndices<'_> {
  USentenceBoundIndices {
  start_offset: source.as_ptr() as usize,
  iter: new_sentence_bounds(source),
  }
 }
 
 #[inline]
-pub fn new_unicode_sentences<'b>(s: &'b str) -> UnicodeSentences<'b> {
+pub fn new_unicode_sentences(s: &str) -> UnicodeSentences<'_> {
  use super::UnicodeSegmentation;
  use crate::tables::util::is_alphanumeric;
 
  fn has_alphanumeric(s: &&str) -> bool {
- s.chars().any(|c| is_alphanumeric(c))
+ s.chars().any(is_alphanumeric)
  }
  let has_alphanumeric: fn(&&str) -> bool = has_alphanumeric; // coerce to fn pointer
 
@@ -384,7 +382,7 @@ impl<'a> Iterator for USentenceBounds<'a> {
 
  #[inline]
  fn next(&mut self) -> Option<&'a str> {
- if self.sentence_start == None {
+ if self.sentence_start.is_none() {
  if let Some(start_pos) = self.iter.next() {
  self.sentence_start = Some(start_pos)
  } else {