Merge rust-analyzer/smol_str#23

23: modernize r=matklad a=matklad



Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Author: bors[bot]

src/tools/rust-analyzer/lib/smol_str/.github/ci.rs

@@ -0,0 +1,116 @@
+use std::{
+    env, fs,
+    process::{self, Command, ExitStatus, Stdio},
+    time::Instant,
+};
+
+type Error = Box<dyn std::error::Error>;
+type Result<T> = std::result::Result<T, Error>;
+
+fn main() {
+    if let Err(err) = try_main() {
+        eprintln!("{}", err);
+        process::exit(1);
+    }
+}
+
+fn try_main() -> Result<()> {
+    let cwd = env::current_dir()?;
+    let cargo_toml = cwd.join("Cargo.toml");
+    assert!(
+        cargo_toml.exists(),
+        "Cargo.toml not found, cwd: {}",
+        cwd.display()
+    );
+
+    {
+        let _s = Section::new("BUILD");
+        shell("cargo test --all-features --workspace --no-run")?;
+    }
+
+    {
+        let _s = Section::new("TEST");
+        shell("cargo test --all-features --workspace")?;
+    }
+
+    let current_branch = shell_output("git branch --show-current")?;
+    if &current_branch == "master" {
+        let _s = Section::new("PUBLISH");
+        let manifest = fs::read_to_string(&cargo_toml)?;
+        let version = get_field(&manifest, "version")?;
+        let tag = format!("v{}", version);
+        let tags = shell_output("git tag --list")?;
+
+        if !tags.contains(&tag) {
+            let token = env::var("CRATES_IO_TOKEN").unwrap();
+            shell(&format!("git tag v{}", version))?;
+            shell(&format!("cargo publish --token {}", token))?;
+            shell("git push --tags")?;
+        }
+    }
+    Ok(())
+}
+
+fn get_field<'a>(text: &'a str, name: &str) -> Result<&'a str> {
+    for line in text.lines() {
+        let words = line.split_ascii_whitespace().collect::<Vec<_>>();
+        match words.as_slice() {
+            [n, "=", v, ..] if n.trim() == name => {
+                assert!(v.starts_with('"') && v.ends_with('"'));
+                return Ok(&v[1..v.len() - 1]);
+            }
+            _ => (),
+        }
+    }
+    Err(format!("can't find `{}` in\n----\n{}\n----\n", name, text))?
+}
+
+fn shell(cmd: &str) -> Result<()> {
+    let status = command(cmd).status()?;
+    check_status(status)
+}
+
+fn shell_output(cmd: &str) -> Result<String> {
+    let output = command(cmd).stderr(Stdio::inherit()).output()?;
+    check_status(output.status)?;
+    let res = String::from_utf8(output.stdout)?;
+    let res = res.trim().to_string();
+    println!("{}", res);
+    Ok(res)
+}
+
+fn command(cmd: &str) -> Command {
+    eprintln!("> {}", cmd);
+    let words = cmd.split_ascii_whitespace().collect::<Vec<_>>();
+    let (cmd, args) = words.split_first().unwrap();
+    let mut res = Command::new(cmd);
+    res.args(args);
+    res
+}
+
+fn check_status(status: ExitStatus) -> Result<()> {
+    if !status.success() {
+        Err(format!("$status: {}", status))?;
+    }
+    Ok(())
+}
+
+struct Section {
+    name: &'static str,
+    start: Instant,
+}
+
+impl Section {
+    fn new(name: &'static str) -> Section {
+        println!("::group::{}", name);
+        let start = Instant::now();
+        Section { name, start }
+    }
+}
+
+impl Drop for Section {
+    fn drop(&mut self) {
+        eprintln!("{}: {:.2?}", self.name, self.start.elapsed());
+        println!("::endgroup::");
+    }
+}

src/tools/rust-analyzer/lib/smol_str/.github/workflows/ci.yaml

@@ -0,0 +1,38 @@
+name: CI
+on:
+  pull_request:
+  push:
+    branches:
+    - master
+    - staging
+    - trying
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CI: 1
+  RUST_BACKTRACE: short
+  RUSTFLAGS: -D warnings
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  rust:
+    name: Rust
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        override: true
+
+    - run: rustc ./.github/ci.rs && ./ci
+      env:
+        CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

src/tools/rust-analyzer/lib/smol_str/.gitignore

@@ -1,2 +1,3 @@
-target/
+/target
+/ci
 Cargo.lock

src/tools/rust-analyzer/lib/smol_str/.travis.yml

@@ -1,21 +1,16 @@
 [package]
 name = "smol_str"
-version = "0.1.16"
-authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
-repository = "https://github.com/matklad/smol_str"
+version = "0.1.17"
 description = "small-string optimized string type with O(1) clone"
 license = "MIT OR Apache-2.0"
+repository = "https://github.com/matklad/smol_str"
+authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
 edition = "2018"
 
 [dependencies]
 serde = { version = "1", optional = true, default_features = false, features = [ "std" ] }
 
 [dev-dependencies]
-proptest = "0.8.3"
+proptest = "0.10"
 serde_json = "1"
 serde =  { version = "1", features = [ "derive" ] }
-criterion = "0.2"
-
-[[bench]]
-name = "building"
-harness = false

src/tools/rust-analyzer/lib/smol_str/Cargo.toml

@@ -1,4 +1,2 @@
-status = [
-  "continuous-integration/travis-ci/push",
-]
+status = [ "Rust" ]
 delete_merged_branches = true

src/tools/rust-analyzer/lib/smol_str/benches/building.rs

@@ -25,67 +25,7 @@ use std::{
 pub struct SmolStr(Repr);
 
 impl SmolStr {
-    /// Constructs an inline variant of `SmolStr` at compile time.
-    ///
-    /// # Parameters
-    ///
-    /// - `len`: Must be short (≤ 22 bytes)
-    /// - `bytes`: Must be ASCII bytes, and there must be at least `len` of
-    ///   them. If `len` is smaller than the actual len of `bytes`, the string
-    ///   is truncated.
-    ///
-    /// # Returns
-    ///
-    /// A constant `SmolStr` with inline data.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use smol_str::SmolStr;
-    /// const IDENT: SmolStr = SmolStr::new_inline_from_ascii(5, b"hello");
-    /// ```
-    ///
-    /// Given a `len` smaller than the number of bytes in `bytes`, the string is
-    /// cut off:
-    ///
-    /// ```rust
-    /// # use smol_str::SmolStr;
-    /// const SHORT: SmolStr = SmolStr::new_inline_from_ascii(5, b"hello world");
-    /// assert_eq!(SHORT.as_str(), "hello");
-    /// ```
-    ///
-    /// ## Compile-time errors
-    ///
-    /// This will **fail** at compile-time with a message like "index out of
-    /// bounds" on a `_len_is_short` because the string is too large:
-    ///
-    /// ```rust,compile_fail
-    /// # use smol_str::SmolStr;
-    /// const IDENT: SmolStr = SmolStr::new_inline_from_ascii(
-    ///     49,
-    ///     b"hello world, how are you doing this fine morning?",
-    /// );
-    /// ```
-    ///
-    /// Similarly, this will **fail** to compile with "index out of bounds" on
-    /// an `_is_ascii` binding because it contains non-ASCII characters:
-    ///
-    /// ```rust,compile_fail
-    /// # use smol_str::SmolStr;
-    /// const IDENT: SmolStr = SmolStr::new_inline_from_ascii(
-    ///     2,
-    ///     &[209, 139],
-    /// );
-    /// ```
-    ///
-    /// Last but not least, given a `len` that is larger than the number of
-    /// bytes in `bytes`, it will fail to compile with "index out of bounds: the
-    /// len is 5 but the index is 5" on a binding called `byte`:
-    ///
-    /// ```rust,compile_fail
-    /// # use smol_str::SmolStr;
-    /// const IDENT: SmolStr = SmolStr::new_inline_from_ascii(10, b"hello");
-    /// ```
+    #[deprecated = "Use `new_inline` instead"]
     pub const fn new_inline_from_ascii(len: usize, bytes: &[u8]) -> SmolStr {
         let _len_is_short = [(); INLINE_CAP + 1][len];
 
@@ -108,6 +48,23 @@ impl SmolStr {
         })
     }
 
+    /// Constructs inline variant of `SmolStr`.
+    ///
+    /// Panics if `text.len() > 22`.
+    #[inline]
+    pub const fn new_inline(text: &str) -> SmolStr {
+        let mut buf = [0; INLINE_CAP];
+        let mut i = 0;
+        while i < text.len() {
+            buf[i] = text.as_bytes()[i];
+            i += 1
+        }
+        SmolStr(Repr::Inline {
+            len: text.len() as u8,
+            buf,
+        })
+    }
+
     pub fn new<T>(text: T) -> SmolStr
     where
         T: AsRef<str>,

src/tools/rust-analyzer/lib/smol_str/bors.toml

@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate proptest;
+use proptest::{prop_assert, prop_assert_eq, proptest};
 
 use smol_str::SmolStr;
 
@@ -27,6 +26,20 @@ fn conversions() {
 
 #[test]
 fn const_fn_ctor() {
+    const EMPTY: SmolStr = SmolStr::new_inline("");
+    const A: SmolStr = SmolStr::new_inline("A");
+    const HELLO: SmolStr = SmolStr::new_inline("HELLO");
+    const LONG: SmolStr = SmolStr::new_inline("ABCDEFGHIZKLMNOPQRSTUV");
+
+    assert_eq!(EMPTY, SmolStr::from(""));
+    assert_eq!(A, SmolStr::from("A"));
+    assert_eq!(HELLO, SmolStr::from("HELLO"));
+    assert_eq!(LONG, SmolStr::from("ABCDEFGHIZKLMNOPQRSTUV"));
+}
+
+#[allow(deprecated)]
+#[test]
+fn old_const_fn_ctor() {
     const EMPTY: SmolStr = SmolStr::new_inline_from_ascii(0, b"");
     const A: SmolStr = SmolStr::new_inline_from_ascii(1, b"A");
     const HELLO: SmolStr = SmolStr::new_inline_from_ascii(5, b"HELLO");