Minimize msrv using a feature controlled macro

Author: Daniel-Aaron-Bloom

.github/workflows/ci.yml

@@ -1,8 +1,8 @@
 on:
   push:
-    branches: [master]
+    branches: [ master ]
   pull_request:
-    branches: [master]
+    branches: [ master ]
 
 name: Continuous integration
 
@@ -17,21 +17,21 @@ jobs:
     strategy:
       matrix:
         include:
-          - rust: 1.83.0 # MSRV
+          - rust: 1.57.0 # MSRV
             features: serde
             experimental: false
-          - rust: 1.85.0
-            features: serde
+          - rust: 1.70.0
+            features: serde, const
             experimental: false
           - rust: stable
-            features:
+            features: const
             bench: true
             experimental: false
           - rust: beta
-            features: serde
+            features: serde, const
             experimental: false
           - rust: nightly
-            features: serde, borsh, zeroize
+            features: serde, borsh, zeroize, const
             experimental: false
 
     steps:
@@ -40,7 +40,7 @@ jobs:
         with:
           toolchain: ${{ matrix.rust }}
       - name: Pin versions for MSRV
-        if: "${{ matrix.rust == '1.83.0' }}"
+        if: "${{ matrix.rust == '1.57.0' }}"
         run: |
           cargo update -p serde_test --precise 1.0.163
           cargo update -p serde --precise 1.0.69
@@ -78,6 +78,7 @@ jobs:
         run: |
           cargo rustc "--target=${{ matrix.target }}" --no-default-features --features "${{ matrix.features }}"
 
+
   miri:
     runs-on: ubuntu-latest
     steps:

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.7.6"
 authors = ["bluss"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
-rust-version = "1.83"
+rust-version = "1.57"
 
 description = "A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString."
 documentation = "https://docs.rs/arrayvec/"
@@ -48,14 +48,15 @@ harness = false
 [features]
 default = ["std"]
 std = []
+const = []
 
 [profile.bench]
 debug = true
 [profile.release]
 debug = true
 
 [package.metadata.docs.rs]
-features = ["borsh", "serde", "zeroize"]
+features = ["borsh", "serde", "zeroize", "const"]
 
 [package.metadata.release]
 no-dev-version = true

src/array_string.rs

@@ -17,6 +17,7 @@ use crate::CapacityError;
 use crate::LenUint;
 use crate::char::encode_utf8;
 use crate::utils::MakeMaybeUninit;
+use crate::const_fn;
 
 #[cfg(feature="serde")]
 use serde::{Serialize, Deserialize, Serializer, Deserializer};
@@ -50,6 +51,8 @@ impl<const CAP: usize> Default for ArrayString<CAP>
 
 impl<const CAP: usize> ArrayString<CAP>
 {
+
+    const_fn!{
     /// Create a new empty `ArrayString`.
     ///
     /// Capacity is inferred from the type parameter.
@@ -67,7 +70,7 @@ impl<const CAP: usize> ArrayString<CAP>
         unsafe {
             ArrayString { xs: MaybeUninit::uninit().assume_init(), len: 0 }
         }
-    }
+    }}
 
     /// Create a new empty `ArrayString` (const fn).
     ///
@@ -91,6 +94,7 @@ impl<const CAP: usize> ArrayString<CAP>
     #[inline]
     pub const fn is_empty(&self) -> bool { self.len() == 0 }
 
+    const_fn!{
     /// Create a new `ArrayString` from a `str`.
     ///
     /// Capacity is inferred from the type parameter.
@@ -111,8 +115,9 @@ impl<const CAP: usize> ArrayString<CAP>
             Ok(()) => Ok(arraystr),
             Err(e) => Err(e),
         }
-    }
+    }}
 
+    const_fn!{
     /// Create a new `ArrayString` from a byte string literal.
     ///
     /// **Errors** if the byte string literal is not valid UTF-8.
@@ -135,8 +140,9 @@ impl<const CAP: usize> ArrayString<CAP>
             vec.set_len(CAP);
         }
         Ok(vec)
-    }
+    }}
 
+    const_fn!{
     /// Create a new `ArrayString` value fully filled with ASCII NULL characters (`\0`). Useful
     /// to be used as a buffer to collect external data or as a buffer for intermediate processing.
     ///
@@ -157,7 +163,7 @@ impl<const CAP: usize> ArrayString<CAP>
                 len: CAP as _
             }
         }
-    }
+    }}
 
     /// Return the capacity of the `ArrayString`.
     ///
@@ -214,6 +220,7 @@ impl<const CAP: usize> ArrayString<CAP>
         self.try_push(c).unwrap();
     }
 
+    const_fn!{
     /// Adds the given char to the end of the string.
     ///
     /// Returns `Ok` if the push succeeds.
@@ -245,7 +252,7 @@ impl<const CAP: usize> ArrayString<CAP>
                 Err(_) => Err(CapacityError::new(c)),
             }
         }
-    }
+    }}
 
     /// Adds the given string slice to the end of the string.
     ///
@@ -266,6 +273,7 @@ impl<const CAP: usize> ArrayString<CAP>
         self.try_push_str(s).unwrap()
     }
 
+    const_fn!{
     /// Adds the given string slice to the end of the string.
     ///
     /// Returns `Ok` if the push succeeds.
@@ -298,7 +306,7 @@ impl<const CAP: usize> ArrayString<CAP>
             self.set_len(newl);
         }
         Ok(())
-    }
+    }}
 
     /// Removes the last character from the string and returns it.
     ///
@@ -392,13 +400,15 @@ impl<const CAP: usize> ArrayString<CAP>
         ch
     }
 
+    const_fn!{
     /// Make the string empty.
     pub const fn clear(&mut self) {
         unsafe {
             self.set_len(0);
         }
-    }
+    }}
 
+    const_fn!{
     /// Set the strings’s length.
     ///
     /// This function is `unsafe` because it changes the notion of the
@@ -410,34 +420,37 @@ impl<const CAP: usize> ArrayString<CAP>
         // type invariant that capacity always fits in LenUint
         debug_assert!(length <= self.capacity());
         self.len = length as LenUint;
-    }
+    }}
 
+    const_fn!{
     /// Return a string slice of the whole `ArrayString`.
     pub const fn as_str(&self) -> &str {
         unsafe {
             let sl = slice::from_raw_parts(self.as_ptr(), self.len());
             str::from_utf8_unchecked(sl)
         }
-    }
+    }}
 
+    const_fn!{
     /// Return a mutable string slice of the whole `ArrayString`.
     pub const fn as_mut_str(&mut self) -> &mut str {
         unsafe {
             let len = self.len();
             let sl = slice::from_raw_parts_mut(self.as_mut_ptr(), len);
             str::from_utf8_unchecked_mut(sl)
         }
-    }
+    }}
 
     /// Return a raw pointer to the string's buffer.
     pub const fn as_ptr(&self) -> *const u8 {
         self.xs.as_ptr() as *const u8
     }
 
+    const_fn!{
     /// Return a raw mutable pointer to the string's buffer.
     pub const fn as_mut_ptr(&mut self) -> *mut u8 {
         self.xs.as_mut_ptr() as *mut u8
-    }
+    }}
 }
 
 impl<const CAP: usize> Deref for ArrayString<CAP>