Merge pull request #8 from rodrimati1992/0.2_patch

0.2.7 patch

Author: rodrimati1992

Cargo.toml

@@ -3,4 +3,5 @@ members=[
     "const_format",
     "const_format_proc_macros",
     "print_errors",
+    "print_warnings",
 ]

const_format/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "const_format"
-version = "0.2.6"
+version = "0.2.7"
 authors = ["rodrimati1992 <[email protected]>"]
 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]

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.

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 {

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;
 

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;
 

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"}

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
         }
     };
 }

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>>,

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>>,

const_format/src/pargument.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::wrong_self_convention)]
+
 use crate::{
     formatting::{Formatting, FormattingFlags},
     wrapper_types::PWrapper,

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;
             }

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 <[email protected]>"]
 edition = "2018"
 license = "Zlib"

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,
 };
 

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(()),
+        }
     })
 }
 

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;

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>),
+}

const_format_proc_macros/src/format_str_parsing/errors.rs renamed to const_format_proc_macros/src/format_str/errors.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;

const_format_proc_macros/src/format_str_parsing.rs renamed to const_format_proc_macros/src/format_str/parsing.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;
 

const_format_proc_macros/src/format_str_parsing/tests.rs renamed to const_format_proc_macros/src/format_str/tests.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;
 

const_format_proc_macros/src/lib.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());

const_format_proc_macros/src/parse_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(),

const_format_proc_macros/src/utils.rs

@@ -0,0 +1,11 @@
+[package]
+name = "print_clippy_warnings"
+version = "0.1.0"
+authors = ["rodrimati1992 <[email protected]>"]
+edition = "2018"
+
+[features]
+nightly = ["const_format/assert"]
+
+[dependencies]
+const_format = {path = "../const_format/"}