Use assert_matches! instead of if let {} else

2021-08-07T13:48:27+00:00

Hide allocator details from TryReserveError

2021-07-24T21:25:08+00:00

Implement String::remove_matches

2021-03-05T16:27:58+00:00

Fix soundness issue for `replace_range` and `range`

2021-01-19T03:14:38+00:00

Added test for issue #78498

2020-10-29T11:25:02+00:00

Use `T::BITS` instead of `size_of:: * 8`.

2020-09-19T04:54:42+00:00

Rollup merge of #75882 - pickfire:patch-6, r=jyn514

2020-09-15T23:30:36+00:00

Use translated variable for test string Test should be educative, added english translation and pronounciation.

Rollup merge of #75146 - tmiasko:range-overflow, r=Mark-Simulacrum

2020-09-15T23:30:30+00:00

Detect overflow in proc_macro_server subspan * Detect overflow in proc_macro_server subspan * Add tests for overflow in Vec::drain * Add tests for overflow in String / VecDeque operations using ranges

Optimize behavior of vec.split_off(0) (take all)

2020-09-13T21:32:29+00:00

Optimization improvement to `split_off()` so the performance meets the intuitively expected behavior when `at == 0`, avoiding the current behavior of copying the entire vector. The change honors documented behavior that the method leaves the original vector's "previous capacity unchanged". This improvement better supports the pattern for building and flushing a buffer of elements, such as the following: ```rust let mut vec = Vec::new(); loop { vec.push(something); if condition_is_met { process(vec.split_off(0)); } } ``` `Option` wrapping is the first alternative I thought of, but is much less obvious and more verbose: ```rust let mut capacity = 1; let mut vec: Option> = None; loop { vec.get_or_insert_with(|| Vec::with_capacity(capacity)).push(something); if condition_is_met { capacity = vec.capacity(); process(vec.take().unwrap()); } } ``` Directly applying `mem::replace()` could work, but `mem::` functions are typically a last resort, when a developer is actively seeking better performance than the standard library provides, for example. The benefit of the approach to this change is it does not change the existing API contract, but improves the peformance of `split_off(0)` for `Vec`, `String` (which delegates `split_off()` to `Vec`), and any other existing use cases. This change adds tests to validate the behavior of `split_off()` with regard to capacity, as originally documented, and confirm that behavior still holds, when `at == 0`. The change is an implementation detail, and does not require a documentation change, but documenting the new behavior as part of its API contract may benefit future users. (Let me know if I should make that documentation update.) Note, for future consideration: I think it would be helpful to introduce an additional method to `Vec` (if not also to `String`): ``` pub fn take_all(&mut self) -> Self { self.split_off(0) } ``` This would make it more clear how `Vec` supports the pattern, and make it easier to find, since the behavior is similar to other `take()` methods in the Rust standard library.

Move test-cases in string.rs

2020-09-06T03:53:40+00:00

rust/library/alloc/tests/string.rs, branch 1.56.1