1
Fork 0
Commit graph

128 commits

Author SHA1 Message Date
Mark Mansi
20ef0e001a make Vec::new const :P 2018-04-26 12:46:28 -05:00
Mark Mansi
256096da9e Make Vec::new const 2018-04-25 16:33:02 -05:00
George Burton
1133a149f1 Implement From for more types on Cow 2018-04-22 22:57:52 +01:00
Simon Sapin
8a374f2827 Add some f32 and f64 inherent methods in libcore
… previously in the unstable core::num::Float trait.

Per https://github.com/rust-lang/rust/issues/32110#issuecomment-379503183,
the `abs`, `signum`, and `powi` methods are *not* included for now
since they rely on LLVM intrinsics and we haven’t determined yet whether
those instrinsics lower to calls to libm functions on any platform.
2018-04-21 09:47:37 +02:00
kennytm
bf60295211
Rollup merge of #49555 - nox:inline-into-boxed, r=alexcrichton
Inline most of the code paths for conversions with boxed slices

This helps with the specific problem described in #49541, obviously without making any large change to how inlining works in the general case.

Everything involved in the conversions is made `#[inline]`, except for the `<Vec<T>>::into_boxed_slice` entry point which is made `#[inline(always)]` after checking that duplicating the function mentioned in the issue prevented its inlining if I only annotate it with
`#[inline]`.

For the record, that function was:

```rust
pub fn foo() -> Box<[u8]> {
    vec![0].into_boxed_slice()
}
```

To help the inliner's job, we also hoist a `self.capacity() != self.len` check in `<Vec<T>>::shrink_to_fit` and mark it as `#[inline]` too.
2018-04-17 01:50:56 +08:00
bors
1ef1563518 Auto merge of #48945 - clarcharr:iter_exhaust, r=Kimundi
Replace manual iterator exhaust with for_each(drop)

This originally added a dedicated method, `Iterator::exhaust`, and has since been replaced with `for_each(drop)`, which is more idiomatic.

<del>This is just shorthand for `for _ in &mut self {}` or `while let Some(_) = self.next() {}`. This states the intent a lot more clearly than the identical code: run the iterator to completion.

<del>At least personally, my eyes tend to gloss over `for _ in &mut self {}` without fully paying attention to what it does; having a `Drop` implementation akin to:

<del>`for _ in &mut self {}; unsafe { free(self.ptr); }`</del>

<del>Is not as clear as:

<del>`self.exhaust(); unsafe { free(self.ptr); }`

<del>Additionally, I've seen debate over whether `while let Some(_) = self.next() {}` or `for _ in &mut self {}` is more clear, whereas `self.exhaust()` is clearer than both.
2018-04-16 13:21:56 +00:00
Anthony Ramine
b59fa0d9e8 Remove #[inline(always)] on Vec::into_boxed_slice 2018-04-15 10:34:57 +02:00
Mike Hommey
bd9ff8476d Cleanup liballoc use statements
Some modules were still using the deprecated `allocator` module, use the
`alloc` module instead.

Some modules were using `super` while it's not needed.

Some modules were more or less ordering them, and other not, so the
latter have been modified to match the others.
2018-04-14 08:43:13 +09:00
bors
9afed64645 Auto merge of #49551 - scottmcm:deprecate-offset_to, r=KodrAus
Deprecate offset_to; switch core&alloc to using offset_from instead

Bonus: might make code than uses `.len()` on slice iterators faster

cc https://github.com/rust-lang/rust/issues/41079
2018-04-12 08:29:10 +00:00
Anthony Ramine
d4dff03e7c Remove inline on Vec::shrink_to_fit as asked by Alex 2018-04-08 09:03:33 +02:00
kennytm
23689cc8e9
Rollup merge of #49496 - glandium:master, r=sfackler
Add more vec![... ; n] optimizations

vec![0; n], via implementations of SpecFromElem, has an optimization that uses with_capacity_zeroed instead of with_capacity, which will use calloc instead of malloc, and avoid an extra memset.

This PR adds the same optimization for ptr::null, ptr::null_mut, and None, when their in-memory representation is zeroes.
2018-04-05 16:51:21 +08:00
Clar Charr
5c58eec0bd Replace manual iter exhaust with for_each(drop). 2018-04-04 19:10:38 -04:00
kennytm
0cccf810ad
Rollup merge of #49559 - djc:resize-with, r=TimNN
Introduce Vec::resize_with method (see #41758)

In #41758, the libs team decided they preferred `Vec::resize_with` over `Vec::resize_default()`. Here is an implementation to get this moving forward.

I don't know what the removal process for `Vec::resize_default()` should be, so I've left it in place for now. Would be happy to follow up with its removal.
2018-04-04 11:07:18 +02:00
Dirkjan Ochtman
da0ceeff5a Introduce Vec::resize_with method (see #41758) 2018-04-03 17:12:59 +02:00
Aidan Hobson Sayers
9b5859aea1 Remove all unstable placement features
Closes #22181, #27779
2018-04-03 11:02:34 +02:00
Mike Hommey
0df837f792 Add vec!['\0'; n] optimization, like vec![0; n]
Similarly to vec![ptr::null{,_mut}(); n] in previous change, this adds
the optimization for vec!['\0'; n].
2018-04-02 10:44:38 +09:00
Mike Hommey
cc939ac345 Add vec![ptr::null{,_mut}(); n] optimization, like vec![0; n]
vec![0; n], via implementations of SpecFromElem, has an optimization
that uses with_capacity_zeroed instead of with_capacity, which will use
calloc instead of malloc, and avoid an extra memset.

This adds the same optimization for vec![ptr::null(); n] and
vec![ptr::null_mut(); n], assuming their bit value is 0 (which is true
on all currently supported platforms).

This does so by adding an intermediate trait IsZero, which looks very
much like nonzero::Zeroable, but that one is on the way out, and doesn't
apply to pointers anyways.

Adding such a trait allows to avoid repeating the logic using
with_capacity_zeroed or with_capacity, or making the macro more complex
to support generics.
2018-04-02 10:10:12 +09:00
Anthony Ramine
360f2f036d Inline most of the code paths for conversions with boxed slices
This helps with the specific problem described in #49541, obviously without
making any large change to how inlining works in the general case.

Everything involved in the conversions is made `#[inline]`, except for the
`<Vec<T>>::into_boxed_slice` entry point which is made `#[inline(always)]`
after checking that duplicating the function mentioned in the issue prevented
its inlining if I only annotate it with `#[inline]`.

For the record, that function was:

```rust
pub fn foo() -> Box<[u8]> {
    vec![0].into_boxed_slice()
}
```

To help the inliner's job, we also hoist a `self.capacity() != self.len` check
in `<Vec<T>>::shrink_to_fit` and mark it as `#[inline]` too.
2018-04-01 11:56:23 +02:00
Scott McMurray
b394165538 Deprecate offset_to; switch core&alloc to using offset_from instead
Bonus: might make code than uses `.len()` on slice iterators faster
2018-03-31 22:35:37 -07:00
kennytm
361ddfeb13
Rollup merge of #49466 - glandium:master, r=rkruppe
Use f{32,64}::to_bits for is_zero test in vec::SpecFromElem

vec::SpecFromElem provides an optimization to use calloc to fill a Vec
when the element given to fill the Vec is represented by 0.

For floats, the test for that currently used is `x == 0. &&
x.is_sign_positive()`. When compiled in a standalone function, rustc
generates the following assembly:

```
  xorps xmm1, xmm1
  ucomisd xmm0, xmm1
  setnp al
  sete cl
  and cl, al
  movq rax, xmm0
  test rax, rax
  setns al
  and al, cl
  ret
```

A simpler test telling us whether the value is represented by 0, is
`x.to_bits() == 0`, which rustc compiles to:

```
  movq rax, xmm0
  test rax, rax
  sete al
  ret
```

Not that the test is hot in any way, but it also makes it clearer what
the intent in the rust code is.
2018-03-30 01:31:16 +02:00
Simon Sapin
16d3ba1b23 Move RangeArguments to {core::std}::ops and rename to RangeBounds
These unstable items are deprecated:

* The `std::collections::range::RangeArgument` reexport
* The `std::collections::range` module.
2018-03-29 13:12:49 +02:00
Simon Sapin
c3a63970de Move alloc::Bound to {core,std}::ops
The stable reexport `std::collections::Bound` is now deprecated.

Another deprecated reexport could be added in `alloc`,
but that crate is unstable.
2018-03-29 13:12:49 +02:00
Mike Hommey
262be13643 Use f{32,64}::to_bits for is_zero test in vec::SpecFromElem
vec::SpecFromElem provides an optimization to use calloc to fill a Vec
when the element given to fill the Vec is represented by 0.

For floats, the test for that currently used is `x == 0. &&
x.is_sign_positive()`. When compiled in a standalone function, rustc
generates the following assembly:

```
  xorps xmm1, xmm1
  ucomisd xmm0, xmm1
  setnp al
  sete cl
  and cl, al
  movq rax, xmm0
  test rax, rax
  setns al
  and al, cl
  ret
```

A simpler test telling us whether the value is represented by 0, is
`x.to_bits() == 0`, which rustc compiles to:

```
  movq rax, xmm0
  test rax, rax
  sete al
  ret
```

Not that the test is hot in any way, but it also makes it clearer what
the intent in the rust code is.
2018-03-29 09:40:55 +09:00
kennytm
30560bb99a
Rollup merge of #49452 - frewsxcv:frewsxcv-vec-cap-len, r=dtolnay
Clarify "length" wording in `Vec::with_capacity`.

Fixes https://github.com/rust-lang/rust/issues/49448.
2018-03-28 17:55:20 +02:00
Corey Farwell
0d15a3ee54 Clarify "length" wording in Vec::with_capacity. 2018-03-28 14:10:18 +02:00
Diggory Blake
04f6692aaf Implement shrink_to method on collections 2018-03-27 01:39:11 +01:00
snf
92bfcd2b19 implementing fallible allocation API (try_reserve) for Vec, String and HashMap 2018-03-14 03:48:42 -07:00
Guillaume Gomez
a63bf3bb10 Add missing urls 2018-03-09 14:08:59 +01:00
kennytm
8e3493d459
Rollup merge of #47463 - bluss:fused-iterator, r=alexcrichton
Stabilize FusedIterator

FusedIterator is a marker trait that promises that the implementing
iterator continues to return `None` from `.next()` once it has returned
`None` once (and/or `.next_back()`, if implemented).

The effects of FusedIterator are already widely available through
`.fuse()`, but with stable `FusedIterator`, stable Rust users can
implement this trait for their iterators when appropriate.

Closes #35602
2018-03-06 20:52:37 +08:00
Ulrik Sverdrup
c7c23fe948 core: Update stability attributes for FusedIterator 2018-03-03 14:23:05 +01:00
Ulrik Sverdrup
bc651cac8d core: Stabilize FusedIterator
FusedIterator is a marker trait that promises that the implementing
iterator continues to return `None` from `.next()` once it has returned
`None` once (and/or `.next_back()`, if implemented).

The effects of FusedIterator are already widely available through
`.fuse()`, but with stable `FusedIterator`, stable Rust users can
implement this trait for their iterators when appropriate.
2018-03-03 14:14:03 +01:00
Jonathan Behrens
370df40dab Don't have Vec<T> delegate to [T]'s bounds for indexing 2018-03-02 23:25:52 -05:00
Jonathan Behrens
45bdf9cbee Update comments 2018-03-02 23:25:52 -05:00
Jonathan Behrens
46fef766b0 Have Vec use slice's implementations of Index<I> and IndexMut<I> 2018-03-02 23:25:52 -05:00
Matt Brubeck
311fbc9265 [docs] Minor wording changes to drain_filter docs
The docs currently say, "If the closure returns false, it will try
again, and call the closure on the next element."  But this happens
regardless of whether the closure returns true or false.
2018-02-22 12:05:30 -08:00
Sergio Benitez
22aecb9c6e Clarify contiguity of Vec's elements. 2018-02-16 17:08:08 -08:00
Jacob Kiesel
fbad3b2468
Switch to retain calling drain_filter. 2018-02-13 08:48:25 -07:00
Jacob Kiesel
a67749ae87
Swap ptr::read for ptr::drop_in_place 2018-02-08 08:27:53 -07:00
Jacob Kiesel
2a4c018518 Apply optimization from #44355 to retain 2018-02-07 21:23:16 -07:00
bors
9758ff9c0b Auto merge of #47299 - cramertj:unsafe-placer, r=alexcrichton
Make core::ops::Place an unsafe trait

Consumers of `Place` would reasonably expect that the `pointer` function returns a valid pointer to memory that can actually be written to.
2018-01-24 07:22:22 +00:00
Simon Sapin
f19baf0977 Rename std::ptr::Shared to NonNull
`Shared` is now a deprecated `type` alias.

CC https://github.com/rust-lang/rust/issues/27730#issuecomment-352800629
2018-01-20 10:55:16 +01:00
Taylor Cramer
25574e58b6 Make core::ops::Place an unsafe trait 2018-01-09 11:39:23 -08:00
Corey Farwell
301e457989 Fix panic condition docs for Vec::insert.
Fixes https://github.com/rust-lang/rust/issues/47065.
2018-01-01 19:06:59 -08:00
Manish Goregaokar
52c28fffa9 Clarify vec docs on deallocation (fixes #46879) 2017-12-20 08:29:32 -08:00
Simon Sapin
60dc10492c Move PhantomData<T> from Shared<T> to users of both Shared and #[may_dangle]
After discussing [1] today with @pnkfelix and @Gankro,
we concluded that it’s ok for drop checking not to be much smarter
than the current `#[may_dangle]` design which requires an explicit
unsafe opt-in.

[1] https://github.com/rust-lang/rust/issues/27730#issuecomment-316432083
2017-12-16 06:58:16 +01:00
Matt Brubeck
3024c1434a Use Try syntax for Option in place of macros or match 2017-12-09 14:18:33 -08:00
Martin Lindhe
ece9a57d1b fix some typos 2017-11-21 15:33:45 +01:00
Lukas Kalbertodt
da57580736 Remove unused AsciiExt imports and fix tests related to ascii methods
Many AsciiExt imports have become useless thanks to the inherent ascii
methods added in the last commits. These were removed. In some places, I
fully specified the ascii method being called to enforce usage of the
AsciiExt trait. Note that some imports are not removed but tagged with
a `#[cfg(stage0)]` attribute. This is necessary, because certain ascii
methods are not yet available in stage0. All those imports will be
removed later.

Additionally, failing tests were fixed. The test suite should exit
successfully now.
2017-11-03 21:27:40 +01:00
Guillaume Gomez
a28b2465d3 usize index message for vec 2017-10-09 14:45:41 +02:00
Sean Prashad
1ebc7bba79 Resolves #36284 - vec.rs documentation 2017-10-01 12:15:05 -04:00