Merge pull request #8 from rodrimati1992/0.2_patch

rodrimati1992 · web-flow · commit 38301f1e4c01 · 2020-10-07T15:56:53.000-03:00
0.2.7 patch
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,4 +3,5 @@ members=[
     "const_format",
     "const_format_proc_macros",
     "print_errors",
+    "print_warnings",
 ]
diff --git a/const_format/Cargo.toml b/const_format/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "const_format"
-version = "0.2.6"
+version = "0.2.7"
 authors = ["rodrimati1992 <rodrimatt1985@gmail.com>"]
 edition = "2018"
 license = "Zlib"
@@ -34,7 +34,7 @@ only_new_tests = ["testing"]
 all = ["fmt", "derive", "constant_time_as_str", "assert"]
 
 [dependencies.const_format_proc_macros]
-version = "=0.2.6"
+version = "=0.2.7"
 path = "../const_format_proc_macros"
 
 [dev-dependencies]
diff --git a/const_format/src/fmt/error.rs b/const_format/src/fmt/error.rs
@@ -1,3 +1,6 @@
+// <_< clippy you silly
+#![allow(clippy::enum_variant_names)]
+
 use core::fmt::{self, Display};
 
 /// An error while trying to write into a StrWriter.
diff --git a/const_format/src/fmt/formatter.rs b/const_format/src/fmt/formatter.rs
@@ -79,6 +79,11 @@ impl ComputeStrLength {
         self.len
     }
 
+    /// Whether the length of the computed string is zero.
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
     /// For borrowing this mutably in macros,just takes and returns a `&mut Self`.
     #[inline(always)]
     pub const fn borrow_mutably(&mut self) -> &mut Self {
diff --git a/const_format/src/fmt/str_writer_mut.rs b/const_format/src/fmt/str_writer_mut.rs
@@ -755,7 +755,7 @@ macro_rules! write_integer_fn {
                     cursor-=1;
                     let digit = (n & 0b1111) as u8;
                     this_buffer[cursor] = hex_as_ascii(digit);
-                    n = n >> 4;
+                    n >>= 4;
                     if n == 0 { break }
                 }
 
@@ -790,7 +790,7 @@ macro_rules! write_integer_fn {
                     cursor-=1;
                     let digit = (n & 1) as u8;
                     this_buffer[cursor] = hex_as_ascii(digit);
-                    n = n >> 1;
+                    n >>= 1;
                     if n == 0 { break }
                 }
 
@@ -989,7 +989,7 @@ impl<'w, E> StrWriterMut<'w, E> {
         borrow_fields!(self, self_len, self_buffer);
 
         // Truncating non-ascii u8s
-        character = character & 0b111_1111;
+        character &= 0b111_1111;
 
         let end = *self_len + repeated;
 
diff --git a/const_format/src/formatting.rs b/const_format/src/formatting.rs
@@ -230,6 +230,8 @@ pub const fn hex_as_ascii(n: u8) -> u8 {
 }
 
 #[doc(hidden)]
+// Really clippy? Array indexing can panic you know.
+#[allow(clippy::no_effect)]
 pub const FOR_ESCAPING: &ForEscaping = {
     let mut is_backslash_escaped = 0;
 
diff --git a/const_format/src/lib.rs b/const_format/src/lib.rs
@@ -322,6 +322,8 @@
 #![deny(clippy::missing_safety_doc)]
 #![deny(clippy::shadow_unrelated)]
 #![deny(clippy::wildcard_imports)]
+// All The methods that take self by value are for small Copy types
+#![allow(clippy::wrong_self_convention)]
 #![deny(missing_docs)]
 
 include! {"const_debug_derive.rs"}
diff --git a/const_format/src/macros.rs b/const_format/src/macros.rs
@@ -257,7 +257,9 @@ macro_rules! strwriter_as_str {
     ($expr:expr) => {
         unsafe {
             let writer: &'static $crate::StrWriter = $expr;
-            $crate::pmr::transmute::<&'static [u8], &'static str>(writer.as_bytes_alt())
+            #[allow(clippy::transmute_bytes_to_str)]
+            let ret = $crate::pmr::transmute::<&'static [u8], &'static str>(writer.as_bytes_alt());
+            ret
         }
     };
 }
diff --git a/const_format/src/marker_traits/format_marker.rs b/const_format/src/marker_traits/format_marker.rs
@@ -185,6 +185,7 @@ macro_rules! std_kind_impls {
 ///
 /// [`PWrapper`]: ../struct.PWrapper.html
 ///
+#[allow(clippy::type_complexity)]
 pub struct IsAFormatMarker<K, T: ?Sized, R: ?Sized>(
     PhantomData<(
         PhantomData<fn() -> PhantomData<K>>,
diff --git a/const_format/src/marker_traits/write_marker.rs b/const_format/src/marker_traits/write_marker.rs
@@ -181,6 +181,7 @@ where
 ///
 /// [`IsNotAStrWriter`]: ./struct.IsNotAStrWriter.html
 ///
+#[allow(clippy::type_complexity)]
 pub struct IsAWriteMarker<K, T: ?Sized, R: ?Sized>(
     PhantomData<(
         PhantomData<fn() -> PhantomData<K>>,
diff --git a/const_format/src/pargument.rs b/const_format/src/pargument.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::wrong_self_convention)]
+
 use crate::{
     formatting::{Formatting, FormattingFlags},
     wrapper_types::PWrapper,
diff --git a/const_format/src/wrapper_types/pwrapper.rs b/const_format/src/wrapper_types/pwrapper.rs
@@ -312,7 +312,7 @@ impl PWrapper<Integer> {
             out.start -= 1;
             let digit = (n & 1) as u8;
             out.array[out.start] = b'0' + digit;
-            n = n >> 1;
+            n >>= 1;
             if n == 0 {
                 break;
             }
@@ -352,7 +352,7 @@ impl PWrapper<Integer> {
                 0..=9 => b'0' + digit,
                 _ => b'A' - 10 + digit,
             };
-            n = n >> 4;
+            n >>= 4;
             if n == 0 {
                 break;
             }
diff --git a/const_format_proc_macros/Cargo.toml b/const_format_proc_macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "const_format_proc_macros"
-version = "0.2.6"
+version = "0.2.7"
 authors = ["rodrimati1992 <rodrimatt1985@gmail.com>"]
 edition = "2018"
 license = "Zlib"
diff --git a/const_format_proc_macros/src/format_args.rs b/const_format_proc_macros/src/format_args.rs
@@ -1,5 +1,5 @@
 use crate::{
-    format_str_parsing::FormatStr, formatting::FormattingFlags, parse_utils::StrRawness,
+    format_str::FormatStr, formatting::FormattingFlags, parse_utils::StrRawness,
     parse_utils::TokenStream2Ext, shared_arg_parsing::ExprArg, spanned::Spans,
 };
 
diff --git a/const_format_proc_macros/src/format_args/parsing.rs b/const_format_proc_macros/src/format_args/parsing.rs
@@ -4,7 +4,7 @@ use super::{
 };
 
 use crate::{
-    format_str_parsing::{FmtArg, FmtStrComponent, FormatStr, WhichArg},
+    format_str::{FmtArg, FmtStrComponent, FormatStr, WhichArg},
     parse_utils::{LitStr, MyParse, ParseBuffer, ParseStream, TokenTreeExt},
     shared_arg_parsing::ExprArg,
     spanned::Spans,
@@ -70,7 +70,7 @@ fn parse_fmt_lit(this: &mut FormatStr, input: ParseStream<'_>) -> Result<(), cra
     input.parse_unwrap_tt(|input| {
         let tt = input.next();
 
-        let res = match tt {
+        match tt {
             Some(TokenTree::Literal(lit)) => {
                 let mut lit = lit_str_to_fmt_lit(&LitStr::parse_from_literal(&lit)?)?;
 
@@ -89,10 +89,8 @@ fn parse_fmt_lit(this: &mut FormatStr, input: ParseStream<'_>) -> Result<(), cra
                 }
                 Ok(())
             }
-            _ => return Ok(()),
-        };
-
-        res
+            _ => Ok(()),
+        }
     })
 }
 
diff --git a/const_format_proc_macros/src/format_macro.rs b/const_format_proc_macros/src/format_macro.rs
@@ -31,6 +31,7 @@ pub(crate) fn concatcp_impl(value: ExprArgs) -> Result<TokenStream2, crate::Erro
 
             let #fmt_var = __cf_osRcTFl4A::pmr::FormattingFlags::NEW;
 
+            #[allow(clippy::eval_order_dependence)]
             let array = [
                 #({
                     let arg = #concat_args;
@@ -95,6 +96,7 @@ pub(crate) fn formatcp_impl(fmt_args: FormatArgs) -> Result<TokenStream2, crate:
 
             #( #locals )*
 
+            #[allow(clippy::eval_order_dependence)]
             let array = [
                 #({
                     let arg = #parg_constructor;
diff --git a/const_format_proc_macros/src/format_str.rs b/const_format_proc_macros/src/format_str.rs
@@ -0,0 +1,35 @@
+use crate::{formatting::FormattingFlags, parse_utils::StrRawness};
+
+mod errors;
+
+mod parsing;
+
+#[cfg(test)]
+mod tests;
+
+pub(crate) use self::errors::{ParseError, ParseErrorKind};
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct FormatStr {
+    pub(crate) list: Vec<FmtStrComponent>,
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum FmtStrComponent {
+    Str(String, StrRawness),
+    Arg(FmtArg),
+}
+
+/// An argument in the format string eg: `"{foo:?}"`
+#[derive(Debug, PartialEq)]
+pub(crate) struct FmtArg {
+    pub(crate) which_arg: WhichArg,
+    pub(crate) formatting: FormattingFlags,
+    pub(crate) rawness: StrRawness,
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum WhichArg {
+    Ident(String),
+    Positional(Option<usize>),
+}
diff --git a/const_format_proc_macros/src/format_str/errors.rs b/const_format_proc_macros/src/format_str/errors.rs
diff --git a/const_format_proc_macros/src/format_str/parsing.rs b/const_format_proc_macros/src/format_str/parsing.rs
@@ -1,48 +1,16 @@
+use super::{FmtArg, FmtStrComponent, FormatStr, ParseError, ParseErrorKind, WhichArg};
+
 use crate::{
     formatting::{FormattingFlags, IsAlternate, NumberFormatting},
     parse_utils::StrRawness,
 };
 
-mod errors;
-
-#[cfg(test)]
-mod tests;
-
-pub(crate) use self::errors::{ParseError, ParseErrorKind};
-
-#[derive(Debug, PartialEq)]
-pub(crate) struct FormatStr {
-    pub(crate) list: Vec<FmtStrComponent>,
-}
-
-#[derive(Debug, PartialEq)]
-pub(crate) enum FmtStrComponent {
-    Str(String, StrRawness),
-    Arg(FmtArg),
-}
-
-/// An argument in the format string eg: `"{foo:?}"`
-#[derive(Debug, PartialEq)]
-pub(crate) struct FmtArg {
-    pub(crate) which_arg: WhichArg,
-    pub(crate) formatting: FormattingFlags,
-    pub(crate) rawness: StrRawness,
-}
-
-#[derive(Debug, PartialEq)]
-pub(crate) enum WhichArg {
-    Ident(String),
-    Positional(Option<usize>),
-}
-
-/////////////////////////////////////
-
 #[cfg(test)]
 impl FmtStrComponent {
-    fn str(s: &str) -> Self {
+    pub(super) fn str(s: &str) -> Self {
         Self::Str(s.to_string(), StrRawness::dummy())
     }
-    fn arg(which_arg: WhichArg, formatting: FormattingFlags) -> Self {
+    pub(super) fn arg(which_arg: WhichArg, formatting: FormattingFlags) -> Self {
         Self::Arg(FmtArg {
             which_arg,
             formatting,
@@ -63,7 +31,7 @@ impl FmtArg {
 
 #[allow(dead_code)]
 impl WhichArg {
-    fn ident(s: &str) -> Self {
+    pub(super) fn ident(s: &str) -> Self {
         Self::Ident(s.to_string())
     }
 }
@@ -98,7 +66,7 @@ fn parse_format_str(input: &str, rawness: StrRawness) -> Result<FormatStr, Parse
 
         if let Some(open_pos) = open_pos {
             let after_open = open_pos + 1;
-            if input[after_open..].chars().next() == Some('{') {
+            if input[after_open..].starts_with('{') {
                 components.push_arg_str("{".to_string(), rawness);
 
                 arg_start = open_pos + 2;
diff --git a/const_format_proc_macros/src/format_str/tests.rs b/const_format_proc_macros/src/format_str/tests.rs
@@ -2,7 +2,7 @@ use super::*;
 
 use super::{ParseError as PE, ParseErrorKind as PEK};
 
-use crate::formatting::{FormattingFlags as FF, IsAlternate};
+use crate::formatting::{FormattingFlags as FF, IsAlternate, NumberFormatting};
 
 use fastrand::Rng;
 
diff --git a/const_format_proc_macros/src/lib.rs b/const_format_proc_macros/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::or_fun_call)]
+
 use proc_macro::TokenStream as TokenStream1;
 
 use proc_macro2::TokenStream as TokenStream2;
@@ -16,7 +18,7 @@ mod derive_debug;
 
 mod format_args;
 
-mod format_str_parsing;
+mod format_str;
 
 mod format_macro;
 
diff --git a/const_format_proc_macros/src/parse_utils.rs b/const_format_proc_macros/src/parse_utils.rs
@@ -169,8 +169,8 @@ impl LitStr {
         let mut range = 1..value.len() - 1;
         let span = literal.span();
 
-        let is_raw = if value.starts_with("r") {
-            let hashes = value[1..].bytes().take_while(|x| *x == b'#').count();
+        let is_raw = if let Some(suffix) = value.strip_prefix('r') {
+            let hashes = suffix.bytes().take_while(|x| *x == b'#').count();
 
             if value.as_bytes()[1 + hashes] != b'"' {
                 return Err(Error::new(
@@ -263,7 +263,7 @@ impl StrRawness {
                 buffer.push('"');
                 buffer.push_str(str);
                 buffer.push('"');
-                buffer.extend(hashes.clone());
+                buffer.extend(hashes);
             }
             None => {
                 buffer.reserve(2 + str.len());
diff --git a/const_format_proc_macros/src/utils.rs b/const_format_proc_macros/src/utils.rs
@@ -31,6 +31,7 @@ pub struct Peekable2<I: Iterator> {
 }
 
 impl Peekable2<std::ops::Range<u8>> {
+    #[allow(clippy::new_ret_no_self)]
     pub fn new<I: IntoIterator>(iter: I) -> Peekable2<I::IntoIter> {
         Peekable2 {
             iter: iter.into_iter().fuse(),
diff --git a/print_clippy_warnings/Cargo.toml b/print_clippy_warnings/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "print_clippy_warnings"
+version = "0.1.0"
+authors = ["rodrimati1992 <rodrimatt1985@gmail.com>"]
+edition = "2018"
+
+[features]
+nightly = ["const_format/assert"]
+
+[dependencies]
+const_format = {path = "../const_format/"}
diff --git a/print_clippy_warnings/src/main.rs b/print_clippy_warnings/src/main.rs
diff --git a/print_warnings/Cargo.toml b/print_warnings/Cargo.toml
diff --git a/print_warnings/src/main.rs b/print_warnings/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,5 @@ members=[`
`3`	`3`	`"const_format",`
`4`	`4`	`"const_format_proc_macros",`
`5`	`5`	`"print_errors",`
	`6`	`+ "print_warnings",`
`6`	`7`	`]`
Original file line number	Diff line number	Diff line change
`@@ -230,6 +230,8 @@ pub const fn hex_as_ascii(n: u8) -> u8 {`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`#[doc(hidden)]`
	`233`	`+// Really clippy? Array indexing can panic you know.`
	`234`	`+#[allow(clippy::no_effect)]`
`233`	`235`	`pub const FOR_ESCAPING: &ForEscaping = {`
`234`	`236`	`let mut is_backslash_escaped = 0;`
`235`	`237`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,9 @@ macro_rules! strwriter_as_str {`
`257`	`257`	`($expr:expr) => {`
`258`	`258`	`unsafe {`
`259`	`259`	`let writer: &'static $crate::StrWriter = $expr;`
`260`		`- $crate::pmr::transmute::<&'static [u8], &'static str>(writer.as_bytes_alt())`
	`260`	`+ #[allow(clippy::transmute_bytes_to_str)]`
	`261`	`+ let ret = $crate::pmr::transmute::<&'static [u8], &'static str>(writer.as_bytes_alt());`
	`262`	`+ ret`
`261`	`263`	`}`
`262`	`264`	`};`
`263`	`265`	`}`