Commit Graph

2733 Commits

Author SHA1 Message Date
Mara Bos
b34cf1a9e1 Swap body of array::IntoIter::new and IntoIterator::new. 2021-12-04 19:15:47 +01:00
Mara Bos
911ee9403e Deprecate array::IntoIter::new. 2021-12-04 19:15:44 +01:00
Mara Bos
16711fe076
Update stabilization version of try_from_mut_slice_to_array 2021-12-04 17:17:12 +01:00
woppopo
8f68bdc380 Make Borrow and BorrowMut impls const 2021-12-04 21:57:39 +09:00
Matthias Krüger
c223a1c109
Rollup merge of #87054 - kit-981:master, r=scottmcm
Add a `try_reduce` method to the Iterator trait

Tracking issue: #87053
2021-12-04 10:42:19 +01:00
Scott McMurray
eb846dbaca Override Iterator::advance(_back)_by for array::IntoIter
Because I happened to notice that `nth` is currently getting codegen'd as a loop even for `Copy` types: <https://rust.godbolt.org/z/fPqv7Gvs7>
2021-12-03 21:36:51 -08:00
kit
aef59e4fb8 Add a try_reduce method to the Iterator trait 2021-12-04 15:17:14 +11:00
Matthias Krüger
0bd4ee79e0
Rollup merge of #90851 - ibraheemdev:downcast-unchecked, r=scottmcm
Add unchecked downcast methods

```rust
impl dyn Any (+ Send + Sync) {
    pub unsafe fn downcast_ref_unchecked<T: Any>(&self) -> &T;
    pub unsafe fn downcast_mut_unchecked<T: Any>(&mut self) -> &mut T;
}

impl<A: Allocator> Box<dyn Any (+ Send + Sync), A> {
    pub unsafe fn downcast_unchecked<T: Any>(&self) -> Box<T, A>;
}
```
2021-12-04 02:26:21 +01:00
bors
532d2b14c0 Auto merge of #90737 - eholk:intofuture, r=tmandry
Reintroduce `into_future` in `.await` desugaring

This is a reintroduction of the remaining parts from https://github.com/rust-lang/rust/pull/65244 that have not been relanded yet.

This isn't quite ready to merge yet. The last attempt was reverting due to performance regressions, so we need to make sure this does not introduce those issues again.

Issues #67644, #67982

/cc `@yoshuawuyts`
2021-12-03 19:29:21 +00:00
bors
d47a6cc3f2 Auto merge of #91286 - scottmcm:residual-trait, r=joshtriplett
Make `array::{try_from_fn, try_map}` and `Iterator::try_find` generic over `Try`

Fixes #85115

This only updates unstable functions.

`array::try_map` didn't actually exist before; this adds it under the still-open tracking issue #79711 from the old PR #79713.

Tracking issue for the new trait: #91285

This would also solve the return type question in for the proposed `Iterator::try_reduce` in #87054
2021-12-03 10:15:11 +00:00
Matthias Krüger
94cd0259f2
Rollup merge of #90269 - woppopo:const_option_expect, r=yaahc
Make `Option::expect` unstably const

Tracking issue: #67441
2021-12-03 06:24:11 +01:00
Jubilee Young
eef4371a98 Force splatting in SIMD test 2021-12-02 19:22:00 -08:00
Scott McMurray
92c8317d2a Add [T]::as_simd(_mut)
SIMD-style optimizations are the most common use for `[T]::align_to(_mut)`, but that's `unsafe`.  So these are *safe* wrappers around it, now that we have the `Simd` type available, to make it easier to use.

```rust
impl [T] {
    pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T]);
    pub fn as_simd_mut<const LANES: usize>(&mut self) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T]);
}
```
2021-12-02 18:14:37 -08:00
Matthias Krüger
fbfa003016
Rollup merge of #91444 - RalfJung:miri-tests, r=dtolnay
disable tests in Miri that take too long

Comparing slices of length `usize::MAX` diverges in Miri. In fact these tests even diverge in rustc unless `-O` is passed. I tried this code to check that:
```rust
#![feature(slice_take)]

const EMPTY_MAX: &'static [()] = &[(); usize::MAX];

fn main() {
    let mut slice: &[_] = &[(); usize::MAX];
    println!("1");
    assert_eq!(Some(&[] as _), slice.take(usize::MAX..));
    println!("2");
    let remaining: &[_] = EMPTY_MAX;
    println!("3");
    assert_eq!(remaining, slice);
    println!("4");
}
```
So, disable these tests in Miri for now.
2021-12-02 22:16:14 +01:00
Eric Holk
0cb769347d Code review feedback
Add a note about `IntoFuture` in error messages where T is not a future.

Change await-into-future.rs to be a run-pass test.
2021-12-02 11:36:56 -08:00
Scott McMurray
b96b9b4093 Make array::{try_from_fn, try_map} and Iterator::try_find generic over Try
Fixes 85115

This only updates unstable functions.

`array::try_map` didn't actually exist before, despite the tracking issue 79711 still being open from the old PR 79713.
2021-12-02 11:23:50 -08:00
Matthias Krüger
d96ce3ea8e
Rollup merge of #91394 - Mark-Simulacrum:bump-stage0, r=pietroalbini
Bump stage0 compiler

r? `@pietroalbini` (or anyone else)
2021-12-02 15:52:03 +01:00
Ralf Jung
b11d88006c disable tests in Miri that take too long 2021-12-01 22:48:59 -05:00
Matthias Krüger
9f1f42897d
Rollup merge of #88502 - ibraheemdev:slice-take, r=dtolnay
Add slice take methods

Revival of #62282

This PR adds the following slice methods:

- `take`
- `take_mut`
- `take_first`
- `take_first_mut`
- `take_last`
- `take_last_mut`

r? `@LukasKalbertodt`
2021-12-01 20:57:42 +01:00
Matthias Krüger
ce197e2bce
Rollup merge of #91346 - ibraheemdev:result-inspect, r=dtolnay
Add `Option::inspect` and `Result::{inspect, inspect_err}`

```rust
// core::result

impl Result<T, E> {
    pub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self;
    pub fn inspect_err<F: FnOnce(&E)>(self, f: F) -> Self;
}

// core::option

impl Option<T> {
    pub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self;
}
```
2021-12-01 10:50:22 +01:00
Mark Rousskov
b221c877e8 Apply cfg-bootstrap switch 2021-11-30 10:51:42 -05:00
Yuki Okushi
28176a4a33
Rollup merge of #91383 - ScriptDevil:drop-while-doc-alias, r=joshtriplett
Add `drop_while` as doc alias to `Iterator::skip_while`

`skip_while` is commonly referred to as `drop_while` in other languages (clojure/c++/haskell). This recently came up in [Zulip](https://rust-lang.zulipchat.com/#narrow/stream/122651-general/topic/.E2.9C.94.20DropWhile/near/262203352) as well.

This pull request adds 'drop_while' as a doc-alias for 'skip_while'.

r? `@joshtriplett`
2021-11-30 17:29:13 +09:00
Yuki Okushi
a940c68035
Rollup merge of #91323 - RalfJung:assert-type, r=oli-obk
CTFE: support assert_zero_valid and assert_uninit_valid

This ensures the implementation of all three type-based assert_ intrinsics remains consistent in Miri.

`assert_inhabited` recently got stabilized in https://github.com/rust-lang/rust/pull/90896 (meaning stable `const fn` can call it), so do the same with these other intrinsics.

Cc ```@rust-lang/wg-const-eval```
2021-11-30 17:29:09 +09:00
Ashok Gautham Jadatharan
dea3494b31 Add drop_while as doc alias to Iterator::skip_while 2021-11-30 10:27:16 +05:30
bors
94bec90702 Auto merge of #91244 - dtolnay:lossy, r=Mark-Simulacrum
Eliminate bunch of copies of error codepath from Utf8LossyChunksIter

Using a macro to stamp out 7 identical copies of the nontrivial slicing logic to exit this loop didn't seem like a necessary use of a macro. The early return case can be handled by `break` without practically any changes to the logic inside the loop.

All this code is from early 2014 (#12062&mdash;nearly 8 years ago; pre-1.0) so it's possible there were compiler limitations that forced the macro way at the time.

Confirmed that `x.py bench library/alloc --stage 0 --test-args from_utf8_lossy` is unaffected on my machine.
2021-11-30 01:08:56 +00:00
Ralf Jung
6c3c3e0952 CTFE: support assert_zero_valid and assert_uninit_valid 2021-11-29 11:49:31 -05:00
Ibraheem Ahmed
2e8358e1ab add Option::inspect and Result::{inspect, inspect_err} 2021-11-28 23:31:45 -05:00
Ralf Jung
85558ad5b3 adjust some const_eval_select safety comments 2021-11-28 14:00:58 -05:00
Ralf Jung
15a4ed6937 adjust const_eval_select documentation 2021-11-28 13:54:56 -05:00
Matthias Krüger
af0cf34787
Rollup merge of #90896 - jhpratt:stabilize_const_maybe_uninit, r=oli-obk
Stabilize some `MaybeUninit` behavior as const

This stabilizes the `MaybeUninit::as_ptr`, `MaybeUninit::assume_init`, and `MaybeUninit::assume_init_ref` as `const fn`. `MaybeUninit::as_mut_ptr` has been moved to a new flag: `const_maybe_uninit_as_mut_ptr`, which is blocked on #57349. `MaybeUninit::slice_assume_init_ref` can be `const fn` when the method is stabilized in general.

The relevant intrinsic has been stabilized as `const` as well, though this isn't user-visible. Due to the seemingly unrelated feature name I performed `rg const_assert_type` and found no other instances of it being used.

r? `@oli-obk`

`@rustbot` label: +A-const-fn +S-waiting-on-review +T-libs-api
2021-11-28 10:42:38 +01:00
Jacob Pratt
44b5b838d2
Add test for const MaybeUninit 2021-11-28 01:31:25 -05:00
Jacob Pratt
ad8e6bf5cc
Stabilize some MaybeUninit behavior as const 2021-11-28 01:01:47 -05:00
bors
27d5935df1 Auto merge of #91301 - scottmcm:stabilize-nonzero-ipot, r=nagisa
Stabilize nonzero_is_power_of_two

Closes #81106
FCP has finished in the tracking issue
2021-11-28 05:55:09 +00:00
Scott McMurray
23045eb622 Stabilize nonzero_is_power_of_two
Fixes 81106
FCP has finished in the tracking issue
2021-11-27 13:13:04 -08:00
bors
686e313a9a Auto merge of #91288 - matthiaskrgr:rollup-yp5h41r, r=matthiaskrgr
Rollup of 6 pull requests

Successful merges:

 - #83791 (Weaken guarantee around advancing underlying iterators in zip)
 - #90995 (Document non-guarantees for Hash)
 - #91057 (Expand `available_parallelism` docs in anticipation of cgroup quota support)
 - #91062 (rustdoc: Consolidate static-file replacement mechanism)
 - #91208 (Account for incorrect `where T::Assoc = Ty` bound)
 - #91266 (Use non-generic inner function for pointer formatting)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
2021-11-27 14:29:12 +00:00
bors
5fd3a5c7c1 Auto merge of #89916 - the8472:advance_by-avoid-err-0, r=dtolnay
Fix Iterator::advance_by contract inconsistency

The `advance_by(n)` docs state that in the error case `Err(k)` that k is always less than n.
It also states that `advance_by(0)` may return `Err(0)` to indicate an exhausted iterator.
These statements are inconsistent.
Since only one implementation (Skip) actually made use of that I changed it to return Ok(()) in that case too.

While adding some tests I also found a bug in `Take::advance_back_by`.
2021-11-27 11:31:26 +00:00
Matthias Krüger
073b1208f0
Rollup merge of #91266 - jam1garner:fmt-ptr-fix, r=dtolnay
Use non-generic inner function for pointer formatting

Previously, despite the implementation being type-unaware, `fmt::Pointer`'s implementation for `*const T` in monomorphized. This affects:

* `fmt::Debug` for `*const T`
* `fmt::Debug` for `*mut T`
* `fmt::Pointer` for `*const T`
* `fmt::Pointer` for `*mut T`

And since the implementation is non-trivial, this results in a large amount of LLVM bitcode being generated. For example, with a large bindgen project with Debug implementations enabled, it will generate a lot of calls to `fmt::Debug for *const T`, which in turn will perform codegen for a copy of this function for every type.

For example, in a real-world bindgen'd header I've been testing with (4,189,245 lines of bindgen Rust with layout tests disabled) the difference between a slightly old nightly (`rustc 1.58.0-nightly (e249ce6b2 2021-10-30)`) and this PR:

<details>
<summary>Nightly (Click to Expand)</summary>

```
  Lines           Copies         Function name
  -----           ------         -------------
  7256000 (100%)  216544 (100%)  (TOTAL)
  1815449 (25.0%)  24206 (11.2%) <*const T as core::fmt::Pointer>::fmt
   300248 (4.1%)   29579 (13.7%) <&T as core::fmt::Debug>::fmt
   290328 (4.0%)   24194 (11.2%) <*mut T as core::fmt::Pointer>::fmt
   217746 (3.0%)   24194 (11.2%) <*mut T as core::fmt::Debug>::fmt
   123329 (1.7%)    1486 (0.7%)  core::fmt::builders::DebugList::entries
    72790 (1.0%)    1486 (0.7%)  core::slice::iter::Iter<T>::post_inc_start
    71313 (1.0%)    1486 (0.7%)  core::slice::iter::Iter<T>::new
    68329 (0.9%)    1486 (0.7%)  <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next
    38636 (0.5%)    1486 (0.7%)  <[T] as core::fmt::Debug>::fmt
    26874 (0.4%)    1493 (0.7%)  core::array::<impl core::fmt::Debug for [T; N]>::fmt
    22290 (0.3%)    1486 (0.7%)  core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
    19407 (0.3%)    1493 (0.7%)  core::array::<impl core::ops::index::Index<I> for [T; N]>::index
    19318 (0.3%)    1486 (0.7%)  core::slice::<impl [T]>::iter
    17832 (0.2%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::offset
    17832 (0.2%)    1486 (0.7%)  core::ptr::mut_ptr::<impl *mut T>::offset
    16346 (0.2%)    1486 (0.7%)  <core::ops::range::RangeFull as core::slice::index::SliceIndex<[T]>>::index
    13374 (0.2%)    1486 (0.7%)  <I as core::iter::traits::collect::IntoIterator>::into_iter
    13374 (0.2%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::add
    13371 (0.2%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::is_null
    13371 (0.2%)    1486 (0.7%)  core::ptr::mut_ptr::<impl *mut T>::is_null
    11888 (0.2%)    1486 (0.7%)  core::slice::<impl [T]>::as_ptr
    11879 (0.2%)    1486 (0.7%)  core::ptr::non_null::NonNull<T>::new_unchecked
     7421 (0.1%)    1486 (0.7%)  core::ptr::non_null::NonNull<T>::as_ptr

```

</details>

<details>
<summary>This PR (Click to Expand)</summary>

```
   Lines           Copies         Function name
  -----           ------         -------------
  5684504 (100%)  216542 (100%)  (TOTAL)
   300248 (5.3%)   29579 (13.7%) <&T as core::fmt::Debug>::fmt
   290328 (5.1%)   24194 (11.2%) <*mut T as core::fmt::Pointer>::fmt
   266265 (4.7%)   24206 (11.2%) <*const T as core::fmt::Pointer>::fmt
   217746 (3.8%)   24194 (11.2%) <*mut T as core::fmt::Debug>::fmt
   101039 (1.8%)    1486 (0.7%)  core::fmt::builders::DebugList::entries
    72790 (1.3%)    1486 (0.7%)  core::slice::iter::Iter<T>::post_inc_start
    71313 (1.3%)    1486 (0.7%)  core::slice::iter::Iter<T>::new
    68329 (1.2%)    1486 (0.7%)  <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next
    38636 (0.7%)    1486 (0.7%)  <[T] as core::fmt::Debug>::fmt
    26874 (0.5%)    1493 (0.7%)  core::array::<impl core::fmt::Debug for [T; N]>::fmt
    22290 (0.4%)    1486 (0.7%)  core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
    19407 (0.3%)    1493 (0.7%)  core::array::<impl core::ops::index::Index<I> for [T; N]>::index
    19318 (0.3%)    1486 (0.7%)  core::slice::<impl [T]>::iter
    17832 (0.3%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::offset
    17832 (0.3%)    1486 (0.7%)  core::ptr::mut_ptr::<impl *mut T>::offset
    16346 (0.3%)    1486 (0.7%)  <core::ops::range::RangeFull as core::slice::index::SliceIndex<[T]>>::index
    13374 (0.2%)    1486 (0.7%)  <I as core::iter::traits::collect::IntoIterator>::into_iter
    13374 (0.2%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::add
    13371 (0.2%)    1486 (0.7%)  core::ptr::const_ptr::<impl *const T>::is_null
    13371 (0.2%)    1486 (0.7%)  core::ptr::mut_ptr::<impl *mut T>::is_null
    11888 (0.2%)    1486 (0.7%)  core::slice::<impl [T]>::as_ptr
    11879 (0.2%)    1486 (0.7%)  core::ptr::non_null::NonNull<T>::new_unchecked
     7421 (0.1%)    1486 (0.7%)  core::ptr::non_null::NonNull<T>::as_ptr

```

</details>

Output generated using `cargo llvm-lines` version 0.4.12.

Summary of differences:

| rustc Version | Total LLVM line count | `*const T as fmt::Pointer` LLVM lines | Compilation Time |
|-|-|-|-|
| `nightly` | 7256000 | 1815449 (25.0% of binary) | 537.014 |
| PR | 5684504 (-21.65%) | 266265 (4.7% of binary) (-85.3% from nightly) | 502.990 |

This results in a pretty noticeable as the majority of rustc's time is spent in either codegen or LLVM, in this case, and is significantly improved by disabling derives for `fmt::Debug`, as it prevents generating all this LLVM IR to be handled.

Here's a run time comparison with nightly on the same codebase (commit 454cc5fb built from source vs 37c8f25 from my PR built from source):

<details>
<summary>nightly (Click to Expand)</summary>

```
time:   2.370; rss:   56MB -> 1118MB (+1062MB)	parse_crate
time:   0.000; rss: 1118MB -> 1118MB (   +0MB)	attributes_injection
time:   0.000; rss: 1118MB -> 1118MB (   +0MB)	incr_comp_prepare_session_directory
time:   0.000; rss: 1118MB -> 1118MB (   +0MB)	incr_comp_garbage_collect_session_directories
time:   0.000; rss: 1120MB -> 1120MB (   +0MB)	plugin_loading
time:   0.000; rss: 1120MB -> 1120MB (   +0MB)	plugin_registration
time:   0.000; rss: 1120MB -> 1120MB (   +0MB)	crate_injection
time:  13.897; rss: 1120MB -> 3147MB (+2027MB)	expand_crate
time:   0.002; rss: 3147MB -> 3147MB (   +0MB)	check_unused_macros
time:  13.900; rss: 1120MB -> 3147MB (+2027MB)	macro_expand_crate
time:   0.002; rss: 3147MB -> 3147MB (   +0MB)	maybe_building_test_harness
time:   0.503; rss: 3147MB -> 3147MB (   +0MB)	AST_validation
time:   0.000; rss: 3147MB -> 3147MB (   +0MB)	maybe_create_a_macro_crate
time:   0.002; rss: 3147MB -> 3147MB (   +0MB)	finalize_imports
time:   0.502; rss: 3147MB -> 3153MB (   +6MB)	finalize_macro_resolutions
time:   4.478; rss: 3153MB -> 3574MB ( +420MB)	late_resolve_crate
time:   0.000; rss: 3574MB -> 3574MB (   +0MB)	resolve_main
time:   0.332; rss: 3574MB -> 3574MB (   +0MB)	resolve_check_unused
time:   0.000; rss: 3574MB -> 3574MB (   +0MB)	resolve_report_errors
time:   0.279; rss: 3574MB -> 3574MB (   +0MB)	resolve_postprocess
time:   5.595; rss: 3147MB -> 3574MB ( +427MB)	resolve_crate
time:   0.382; rss: 3574MB -> 3574MB (   +0MB)	complete_gated_feature_checking
time:  20.526; rss: 1120MB -> 3574MB (+2454MB)	configure_and_expand
time:   0.000; rss: 3574MB -> 3574MB (   +0MB)	prepare_outputs
time:   0.000; rss: 3574MB -> 3574MB (   +0MB)	blocked_on_dep_graph_loading
time:  65.992; rss: 3574MB -> 6317MB (+2743MB)	hir_lowering
time:   1.117; rss: 6317MB -> 6323MB (   +6MB)	early_lint_checks
time:   1.447; rss: 6323MB -> 6271MB (  -52MB)	drop_ast
time:   0.002; rss: 5838MB -> 5838MB (   +0MB)	setup_global_ctxt
time:   0.000; rss: 5843MB -> 5843MB (   +0MB)	looking_for_entry_point
time:   0.313; rss: 5843MB -> 5844MB (   +1MB)	looking_for_derive_registrar
time:   9.652; rss: 5843MB -> 6065MB ( +222MB)	misc_checking_1
time:   9.713; rss: 6065MB -> 6769MB ( +704MB)	type_collecting
time:   0.665; rss: 6769MB -> 6769MB (   +0MB)	impl_wf_inference
time:   0.064; rss: 6769MB -> 6769MB (   +0MB)	unsafety_checking
time:   3.095; rss: 6769MB -> 6792MB (  +23MB)	coherence_checking
time:  21.282; rss: 6792MB -> 7546MB ( +754MB)	wf_checking
time:   5.404; rss: 7546MB -> 7681MB ( +135MB)	item_types_checking
time:  79.665; rss: 7681MB -> 8075MB ( +394MB)	item_bodies_checking
time: 120.166; rss: 6065MB -> 8081MB (+2016MB)	type_check_crate
time:   2.038; rss: 8081MB -> 8085MB (   +4MB)	match_checking
time:   1.300; rss: 8085MB -> 8113MB (  +28MB)	liveness_and_intrinsic_checking
time:   3.338; rss: 8081MB -> 8113MB (  +32MB)	misc_checking_2
time:  68.612; rss: 8113MB -> 9285MB (+1172MB)	MIR_borrow_checking
time:   0.622; rss: 9285MB -> 9301MB (  +17MB)	MIR_effect_checking
time:   0.000; rss: 9301MB -> 9301MB (   +0MB)	layout_testing
time:   4.331; rss: 9383MB -> 9510MB ( +127MB)	death_checking
time:   0.032; rss: 9510MB -> 9510MB (   +0MB)	unused_lib_feature_checking
time:   4.444; rss: 9510MB -> 9568MB (  +58MB)	crate_lints
time:  59.563; rss: 9568MB -> 9576MB (   +8MB)	module_lints
time:  64.006; rss: 9510MB -> 9576MB (  +66MB)	lint_checking
time:   4.127; rss: 9576MB -> 9639MB (  +62MB)	privacy_checking_modules
time:  77.984; rss: 9301MB -> 9639MB ( +337MB)	misc_checking_3
time:   0.311; rss: 10357MB -> 10357MB (   +0MB)	monomorphization_collector_root_collections
time:  14.051; rss: 10357MB -> 10573MB ( +217MB)	monomorphization_collector_graph_walk
time:   1.759; rss: 10573MB -> 10652MB (  +79MB)	partition_and_assert_distinct_symbols
time:  28.518; rss: 9639MB -> 10711MB (+1072MB)	generate_crate_metadata
time:   0.000; rss: 10711MB -> 10711MB (   +0MB)	find_cgu_reuse
time:  63.408; rss: 10711MB -> 12272MB (+1560MB)	codegen_to_LLVM_IR
time:  64.916; rss: 10711MB -> 12267MB (+1556MB)	codegen_crate
time:   0.000; rss: 12261MB -> 12261MB (   +0MB)	assert_dep_graph
time:   0.000; rss: 12261MB -> 12261MB (   +0MB)	check_dirty_clean
time:   0.664; rss: 12230MB -> 12210MB (  -20MB)	encode_query_results_for(rustc_query_impl::queries::type_of)
time:   2.111; rss: 12210MB -> 12043MB ( -167MB)	encode_query_results_for(rustc_query_impl::queries::generics_of)
time:   0.108; rss: 12043MB -> 12057MB (  +14MB)	encode_query_results_for(rustc_query_impl::queries::predicates_of)
time:   0.004; rss: 12057MB -> 12059MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::mir_const_qualif)
time:   0.665; rss: 12059MB -> 12121MB (  +62MB)	encode_query_results_for(rustc_query_impl::queries::mir_for_ctfe)
time:  16.149; rss: 12121MB -> 12148MB (  +28MB)	encode_query_results_for(rustc_query_impl::queries::optimized_mir)
time:   0.000; rss: 12148MB -> 12148MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::covered_file_name)
time:   0.000; rss: 12148MB -> 12148MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::covered_code_regions)
time:   0.010; rss: 12148MB -> 12150MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::promoted_mir)
time:   0.052; rss: 12150MB -> 12155MB (   +4MB)	encode_query_results_for(rustc_query_impl::queries::unsafety_check_result)
time:   0.003; rss: 12155MB -> 12156MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::thir_check_unsafety)
time:  11.428; rss: 12156MB -> 11748MB ( -408MB)	encode_query_results_for(rustc_query_impl::queries::typeck)
time:   0.000; rss: 11748MB -> 11748MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::diagnostic_only_typeck)
time:   0.094; rss: 11748MB -> 11756MB (   +8MB)	encode_query_results_for(rustc_query_impl::queries::used_trait_imports)
time:   0.272; rss: 11756MB -> 11778MB (  +22MB)	encode_query_results_for(rustc_query_impl::queries::mir_borrowck)
time:   0.054; rss: 11778MB -> 11778MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::eval_to_allocation_raw)
time:   0.005; rss: 11778MB -> 11779MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::eval_to_const_value_raw)
time:   0.021; rss: 11779MB -> 11784MB (   +5MB)	encode_query_results_for(rustc_query_impl::queries::check_match)
time:   0.041; rss: 11784MB -> 11786MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::symbol_name)
time:   0.743; rss: 11786MB -> 11815MB (  +29MB)	encode_query_results_for(rustc_query_impl::queries::codegen_fn_attrs)
time:   0.043; rss: 11815MB -> 11816MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::codegen_fulfill_obligation)
time:   0.674; rss: 11816MB -> 11840MB (  +25MB)	encode_query_results_for(rustc_query_impl::queries::specialization_graph_of)
time:   0.000; rss: 11840MB -> 11840MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::adt_drop_tys)
time:   0.000; rss: 11840MB -> 11840MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::adt_significant_drop_tys)
time:   0.005; rss: 11840MB -> 11841MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::unused_generic_params)
time:  33.153; rss: 12232MB -> 11841MB ( -390MB)	encode_query_results
time:  88.943; rss: 11955MB -> 11783MB ( -173MB)	LLVM_passes(crate)
time:  38.854; rss: 12259MB -> 10095MB (-2164MB)	incr_comp_serialize_result_cache
time:  39.030; rss: 12261MB -> 10095MB (-2166MB)	incr_comp_persist_result_cache
time:   0.000; rss: 10095MB -> 10095MB (   +0MB)	incr_comp_persist_dep_graph
time:  39.064; rss: 12257MB -> 10095MB (-2162MB)	serialize_dep_graph
time:  19.047; rss: 10095MB -> 10307MB ( +212MB)	free_global_ctxt
time:   0.000; rss: 10307MB -> 10307MB (   +0MB)	join_worker_thread
time:   0.519; rss: 10307MB -> 10307MB (   +0MB)	copy_all_cgu_workproducts_to_incr_comp_cache_dir
time:   0.522; rss: 10307MB -> 10307MB (   +0MB)	finish_ongoing_codegen
time:   0.000; rss: 10307MB -> 10307MB (   +0MB)	llvm_dump_timing_file
time:   0.002; rss: 10307MB -> 10307MB (   +0MB)	serialize_work_products
time:   0.001; rss: 9542MB -> 9542MB (   +0MB)	incr_comp_finalize_session_directory
time:   0.000; rss: 9542MB -> 9542MB (   +0MB)	link_binary_check_files_are_writeable
time:   7.835; rss: 9542MB -> 9544MB (   +2MB)	link_rlib
time:   0.000; rss: 9544MB -> 9544MB (   +0MB)	link_binary_remove_temps
time:   7.872; rss: 9542MB -> 9544MB (   +2MB)	link_binary
time:   7.944; rss: 9542MB -> 9201MB ( -341MB)	link_crate
time:   8.495; rss: 10307MB -> 9201MB (-1106MB)	link
time: 537.014; rss:   33MB -> 3715MB (+3682MB)	total
```

</details>

<details>
<summary>This PR (Click to Expand)</summary>

```
time:   2.379; rss:   51MB -> 1116MB (+1064MB)	parse_crate
time:   0.003; rss: 1116MB -> 1116MB (   +0MB)	attributes_injection
time:   0.002; rss: 1116MB -> 1116MB (   +0MB)	incr_comp_prepare_session_directory
time:   0.000; rss: 1116MB -> 1116MB (   +0MB)	incr_comp_garbage_collect_session_directories
time:   0.000; rss: 1116MB -> 1116MB (   +0MB)	plugin_loading
time:   0.000; rss: 1116MB -> 1116MB (   +0MB)	plugin_registration
time:   0.003; rss: 1118MB -> 1118MB (   +0MB)	crate_injection
time:  13.376; rss: 1118MB -> 3143MB (+2025MB)	expand_crate
time:   0.002; rss: 3143MB -> 3143MB (   +0MB)	check_unused_macros
time:  13.379; rss: 1118MB -> 3143MB (+2025MB)	macro_expand_crate
time:   0.002; rss: 3143MB -> 3143MB (   +0MB)	maybe_building_test_harness
time:   0.479; rss: 3143MB -> 3143MB (   +0MB)	AST_validation
time:   0.002; rss: 3143MB -> 3143MB (   +0MB)	maybe_create_a_macro_crate
time:   0.005; rss: 3143MB -> 3143MB (   +0MB)	finalize_imports
time:   0.520; rss: 3143MB -> 3125MB (  -18MB)	finalize_macro_resolutions
time:   4.446; rss: 3125MB -> 3577MB ( +453MB)	late_resolve_crate
time:   0.000; rss: 3577MB -> 3577MB (   +0MB)	resolve_main
time:   0.336; rss: 3577MB -> 3577MB (   +0MB)	resolve_check_unused
time:   0.000; rss: 3577MB -> 3577MB (   +0MB)	resolve_report_errors
time:   0.295; rss: 3577MB -> 3578MB (   +0MB)	resolve_postprocess
time:   5.602; rss: 3143MB -> 3578MB ( +435MB)	resolve_crate
time:   0.388; rss: 3578MB -> 3578MB (   +0MB)	complete_gated_feature_checking
time:  20.014; rss: 1116MB -> 3578MB (+2462MB)	configure_and_expand
time:   0.000; rss: 3578MB -> 3578MB (   +0MB)	prepare_outputs
time:   0.000; rss: 3578MB -> 3578MB (   +0MB)	blocked_on_dep_graph_loading
time:  64.219; rss: 3578MB -> 6313MB (+2736MB)	hir_lowering
time:   1.102; rss: 6313MB -> 6319MB (   +6MB)	early_lint_checks
time:   1.426; rss: 6319MB -> 6268MB (  -52MB)	drop_ast
time:   0.005; rss: 5834MB -> 5836MB (   +2MB)	setup_global_ctxt
time:   0.000; rss: 5838MB -> 5838MB (   +0MB)	looking_for_entry_point
time:   0.292; rss: 5838MB -> 5840MB (   +1MB)	looking_for_derive_registrar
time:   9.553; rss: 5838MB -> 6060MB ( +222MB)	misc_checking_1
time:   9.949; rss: 6060MB -> 6764MB ( +704MB)	type_collecting
time:   0.630; rss: 6764MB -> 6764MB (   +0MB)	impl_wf_inference
time:   0.060; rss: 6764MB -> 6764MB (   +0MB)	unsafety_checking
time:   3.054; rss: 6764MB -> 6787MB (  +23MB)	coherence_checking
time:  20.702; rss: 6787MB -> 7533MB ( +746MB)	wf_checking
time:   5.194; rss: 7533MB -> 7668MB ( +135MB)	item_types_checking
time:  74.677; rss: 7668MB -> 8062MB ( +394MB)	item_bodies_checking
time: 114.497; rss: 6060MB -> 8068MB (+2008MB)	type_check_crate
time:   1.891; rss: 8068MB -> 8072MB (   +4MB)	match_checking
time:   1.292; rss: 8072MB -> 8100MB (  +28MB)	liveness_and_intrinsic_checking
time:   3.183; rss: 8068MB -> 8100MB (  +32MB)	misc_checking_2
time:  68.845; rss: 8100MB -> 9279MB (+1179MB)	MIR_borrow_checking
time:   0.587; rss: 9279MB -> 9295MB (  +17MB)	MIR_effect_checking
time:   0.000; rss: 9295MB -> 9295MB (   +0MB)	layout_testing
time:   4.443; rss: 9377MB -> 9504MB ( +127MB)	death_checking
time:   0.034; rss: 9504MB -> 9504MB (   +0MB)	unused_lib_feature_checking
time:   4.409; rss: 9504MB -> 9562MB (  +58MB)	crate_lints
time:  56.490; rss: 9562MB -> 9571MB (   +8MB)	module_lints
time:  60.900; rss: 9504MB -> 9571MB (  +66MB)	lint_checking
time:   4.147; rss: 9571MB -> 9633MB (  +62MB)	privacy_checking_modules
time:  75.094; rss: 9295MB -> 9633MB ( +337MB)	misc_checking_3
time:   0.315; rss: 10357MB -> 10357MB (   +0MB)	monomorphization_collector_root_collections
time:  14.501; rss: 10357MB -> 10571MB ( +215MB)	monomorphization_collector_graph_walk
time:   1.763; rss: 10571MB -> 10661MB (  +89MB)	partition_and_assert_distinct_symbols
time:  29.035; rss: 9633MB -> 10706MB (+1073MB)	generate_crate_metadata
time:   0.000; rss: 10706MB -> 10706MB (   +0MB)	find_cgu_reuse
time:  30.913; rss: 10706MB -> 12150MB (+1444MB)	codegen_to_LLVM_IR
time:  31.108; rss: 10706MB -> 12150MB (+1444MB)	codegen_crate
time:   0.000; rss: 12150MB -> 12150MB (   +0MB)	assert_dep_graph
time:   0.000; rss: 12150MB -> 12150MB (   +0MB)	check_dirty_clean
time:   0.416; rss: 12152MB -> 12199MB (  +46MB)	encode_query_results_for(rustc_query_impl::queries::type_of)
time:   1.259; rss: 12199MB -> 12211MB (  +12MB)	encode_query_results_for(rustc_query_impl::queries::generics_of)
time:   0.095; rss: 12211MB -> 12193MB (  -18MB)	encode_query_results_for(rustc_query_impl::queries::predicates_of)
time:   0.005; rss: 12193MB -> 12195MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::mir_const_qualif)
time:   0.828; rss: 12195MB -> 12208MB (  +14MB)	encode_query_results_for(rustc_query_impl::queries::mir_for_ctfe)
time:  17.880; rss: 12208MB -> 11987MB ( -222MB)	encode_query_results_for(rustc_query_impl::queries::optimized_mir)
time:   0.000; rss: 11987MB -> 11987MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::covered_file_name)
time:   0.000; rss: 11987MB -> 11987MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::covered_code_regions)
time:   0.007; rss: 11987MB -> 11988MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::promoted_mir)
time:   0.049; rss: 11988MB -> 11992MB (   +4MB)	encode_query_results_for(rustc_query_impl::queries::unsafety_check_result)
time:   0.002; rss: 11992MB -> 11994MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::thir_check_unsafety)
time:  38.049; rss: 11994MB -> 12093MB (  +99MB)	encode_query_results_for(rustc_query_impl::queries::typeck)
time:   0.000; rss: 12093MB -> 12093MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::diagnostic_only_typeck)
time:   0.024; rss: 12093MB -> 12095MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::used_trait_imports)
time:   0.372; rss: 12095MB -> 12053MB (  -42MB)	encode_query_results_for(rustc_query_impl::queries::mir_borrowck)
time:   0.015; rss: 12053MB -> 12053MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::eval_to_allocation_raw)
time:   0.005; rss: 12053MB -> 12054MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::eval_to_const_value_raw)
time:   0.003; rss: 12054MB -> 12056MB (   +2MB)	encode_query_results_for(rustc_query_impl::queries::check_match)
time:   0.037; rss: 12056MB -> 11899MB ( -157MB)	encode_query_results_for(rustc_query_impl::queries::symbol_name)
time:   0.667; rss: 11899MB -> 11708MB ( -191MB)	encode_query_results_for(rustc_query_impl::queries::codegen_fn_attrs)
time:   0.045; rss: 11708MB -> 11709MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::codegen_fulfill_obligation)
time:   0.295; rss: 11709MB -> 11734MB (  +25MB)	encode_query_results_for(rustc_query_impl::queries::specialization_graph_of)
time:   0.000; rss: 11734MB -> 11734MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::adt_drop_tys)
time:   0.000; rss: 11734MB -> 11734MB (   +0MB)	encode_query_results_for(rustc_query_impl::queries::adt_significant_drop_tys)
time:   0.005; rss: 11734MB -> 11734MB (   +1MB)	encode_query_results_for(rustc_query_impl::queries::unused_generic_params)
time:  60.063; rss: 12152MB -> 11734MB ( -418MB)	encode_query_results
time:  76.745; rss: 12007MB -> 11699MB ( -308MB)	LLVM_passes(crate)
time:  61.634; rss: 12150MB -> 10557MB (-1593MB)	incr_comp_serialize_result_cache
time:  61.637; rss: 12150MB -> 10557MB (-1593MB)	incr_comp_persist_result_cache
time:   0.001; rss: 10557MB -> 10557MB (   +0MB)	incr_comp_persist_dep_graph
time:  61.641; rss: 12150MB -> 10557MB (-1593MB)	serialize_dep_graph
time:  15.601; rss: 10557MB -> 10242MB ( -315MB)	free_global_ctxt
time:   0.000; rss: 10242MB -> 10242MB (   +0MB)	join_worker_thread
time:   0.368; rss: 10242MB -> 10242MB (   +0MB)	copy_all_cgu_workproducts_to_incr_comp_cache_dir
time:   0.375; rss: 10242MB -> 10242MB (   +0MB)	finish_ongoing_codegen
time:   0.000; rss: 10242MB -> 10242MB (   +0MB)	llvm_dump_timing_file
time:   0.002; rss: 10242MB -> 10242MB (   +0MB)	serialize_work_products
time:   0.001; rss: 9668MB -> 9668MB (   +0MB)	incr_comp_finalize_session_directory
time:   0.000; rss: 9668MB -> 9668MB (   +0MB)	link_binary_check_files_are_writeable
time:   1.469; rss: 9668MB -> 9671MB (   +3MB)	link_rlib
time:   0.000; rss: 9671MB -> 9671MB (   +0MB)	link_binary_remove_temps
time:   1.506; rss: 9668MB -> 9671MB (   +3MB)	link_binary
time:   1.622; rss: 9668MB -> 9329MB ( -339MB)	link_crate
time:   2.037; rss: 10242MB -> 9329MB ( -913MB)	link
time: 502.990; rss:   32MB -> 5888MB (+5855MB)	total
```

</details>

(6.34% decrease in runtime, results are consistent across multiple runs)
2021-11-27 11:46:45 +01:00
Matthias Krüger
43279b2749
Rollup merge of #90995 - the8472:hash-portability, r=dtolnay
Document non-guarantees for Hash

Dependence on endianness and type sizes was reported for enum discriminants in #74215 but it is a more general
issue since for example the default implementation of `Hasher::write_usize` uses native endianness.
Additionally the implementations of library types are occasionally changed as their internal fields
change or hashing gets optimized.

## Question

Should this go on the module level documentation instead since it also concerns `Hasher` to some extent and not just `Hash`?

resolves #74215
2021-11-27 11:46:42 +01:00
Matthias Krüger
14ef447d12
Rollup merge of #83791 - the8472:relax-zip-side-effect-guarantee, r=dtolnay
Weaken guarantee around advancing underlying iterators in zip

The current guarantee (introduced in #52279) is too strong as it prevents adapters from exploiting knowledge about the iterator length and using counted loops for example because they would stop calling `next()` before it ever returned `None`. Additionally several nested zip iterators already fail to uphold this.

This does not yet remove any of the specialization code that tries (and sometimes fails) to uphold the guarantee for `next()`
because removing it would also affect `next_back()` in more surprising ways.

The intent is to be able to remove for example this branch

36bcf40697/library/core/src/iter/adapters/zip.rs (L234-L243)

or this test

36bcf40697/library/core/tests/iter/adapters/zip.rs (L177-L188)

Solves #82303 by declaring it a non-issue.
2021-11-27 11:46:40 +01:00
bors
bbad745a68 Auto merge of #91269 - matthiaskrgr:rollup-jh8i8eh, r=matthiaskrgr
Rollup of 7 pull requests

Successful merges:

 - #90611 (Fix another ICE in rustdoc scrape_examples)
 - #91197 (rustdoc: Rename `Type::ResolvedPath` to `Type::Path` and don't re-export it)
 - #91223 (Fix headings indent)
 - #91240 (Saner formatting for UTF8_CHAR_WIDTH table)
 - #91248 (Bump compiler-builtins to 0.1.53)
 - #91252 (Fix bug where submodules wouldn't be updated when running x.py from a subdirectory)
 - #91259 (Remove `--display-doctest-warnings`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
2021-11-27 00:42:30 +00:00
bors
ccce98535b Auto merge of #91246 - nnethercote:faster-layout-array, r=dtolnay
Faster `Layout::array`

`Layout::array` is called (indirectly) by `Vec::push()`, which is typically instantiated many times, and so making it smaller can help with compile times because less LLVM IR is generated.

r? `@ghost`
2021-11-26 21:35:53 +00:00
David Tolnay
c6810a569f
Clarify safety comment on using i to index into self.source 2021-11-26 12:57:36 -08:00
jam1garner
37c8f254ed Use non-generic inner function for pointer formatting 2021-11-26 13:59:57 -05:00
Nicholas Nethercote
f3bda74d36 Optimize Layout::array.
The current implementation is much more conservative than it needs to
be, because it's dealing with the size and alignment of a given `T`,
which are more restricted than an arbitrary `Layout`.

For example, imagine a struct with a `u32` and a `u4`. You can safely
create a `Layout { size_: 5, align_: 4 }` by hand, but
`Layout:🆕:<T>` will give `Layout { size_: 8, align_: 4}`, where the
size already has padding that accounts for the alignment. (And the
existing `debug_assert_eq!` in `Layout::array` already demonstrates that
no additional padding is required.)
2021-11-26 19:30:35 +11:00
Nicholas Nethercote
026edbb4ef Use unchecked construction in Layout::pad_to_align.
Other, similar methods for `Layout` do likewise, and there's already an
`unwrap()` around the result demonstrating the safety.
2021-11-26 19:30:35 +11:00
David Tolnay
2be9a8349f
Eliminate bunch of copies of error codepath from Utf8LossyChunksIter
Using a macro to stamp out 7 identical copies of the nontrivial slicing
logic to exit this loop didn't seem like a necessary use of a macro. The
early return case can be handled by `break` without practically any
changes to the logic inside the loop.

All this code is from early 2014 (7.5 years old, pre-1.0) so it's
possible there were compiler limitations that forced the macro way at
the time.

Confirmed that `x.py bench library/alloc --stage 0 --test-args from_utf8_lossy`
is unaffected on my machine.
2021-11-25 19:52:45 -08:00
David Tolnay
553a84c445
Saner formatting for UTF8_CHAR_WIDTH table 2021-11-25 18:18:36 -08:00
Matthias Krüger
6970cf5a23
Rollup merge of #91096 - compiler-errors:elaborate_opaque_trait, r=estebank
Print associated types on opaque `impl Trait` types

This PR generalizes #91021, printing associated types for all opaque `impl Trait` types instead of just special-casing for future.

before:
```
error[E0271]: type mismatch resolving `<impl Iterator as Iterator>::Item == u32`
```

after:
```
error[E0271]: type mismatch resolving `<impl Iterator<Item = usize> as Iterator>::Item == u32`
```

---

Questions:
1. I'm kinda lost in binders hell with this one. Is all of the `rebind`ing necessary?
2. Is there a map collection type that will give me a stable iteration order? Doesn't seem like TraitRef is Ord, so I can't just sort later..
3. I removed the logic that suppresses printing generator projection types. It creates outputs like this [gist](https://gist.github.com/compiler-errors/d6f12fb30079feb1ad1d5f1ab39a3a8d). Should I put that back?
4. I also added spaces between traits, `impl A+B` -> `impl A + B`. I quite like this change, but is there a good reason to keep it like that?

r? ````@estebank````
2021-11-25 15:05:37 +01:00
Guillaume Gomez
a6a1d7ca29
Rollup merge of #90420 - GuillaumeGomez:rustdoc-internals-feature, r=camelid
Create rustdoc_internals feature gate

As suggested by ``@camelid`` [here](https://github.com/rust-lang/rust/pull/90398#issuecomment-955093851), since `doc_keyword` and `doc_primitive` aren't meant to be stabilized, we could put them behind a same feature flag.

This is pretty much what it would look like (needs to update the tests too).

The tracking issue is https://github.com/rust-lang/rust/issues/90418.

What do you think ``@rust-lang/rustdoc`` ?
2021-11-24 22:56:37 +01:00
Guillaume Gomez
658c148b87
Rollup merge of #89542 - jhpratt:stabilize-duration-const-fns, r=oli-obk
Partially stabilize `duration_consts_2`

Methods that were only blocked on `const_panic` have been stabilized.
The remaining methods of `duration_consts_2` are all related to floats,
and as such have been placed behind the `duration_consts_float` feature
gate.
2021-11-24 22:56:35 +01:00
Guillaume Gomez
1e6ced3532 Create rustdoc_internals feature gate 2021-11-24 21:57:18 +01:00
woppopo
89b2e0c9d5 Make intrinsics::write_bytes const 2021-11-24 13:05:26 +09:00
the8472
53fc69f87c
Apply suggestions from code review
Co-authored-by: pierwill <19642016+pierwill@users.noreply.github.com>
2021-11-23 23:55:05 +01:00
Michael Goulet
b84a52c95a Add generator lang-item 2021-11-23 10:34:16 -08:00
Jacob Pratt
7b103e7dd2
Use derive_default_enum in the compiler 2021-11-22 20:17:53 -05:00
Eric Holk
dfa0db5961 Reintroduce into_future in .await desugaring
This is a reintroduction of the remaining parts from
https://github.com/rust-lang/rust/pull/65244 that have not been relanded
yet.

Issues GH-67644, GH-67982
2021-11-22 14:57:27 -08:00
Jacob Pratt
41f70f3491
Revert "Temporarily rename int_roundings functions to avoid conflicts"
This reverts commit 3ece63b64e.
2021-11-22 15:49:04 -05:00
Jacob Pratt
88b0d7cfc5
Partially stabilize duration_consts_2
Methods that were only blocked on `const_panic` have been stabilized.
The remaining methods of `duration_consts_2` are all related to floats,
and as such have been placed behind the `duration_consts_float` feature
gate.
2021-11-22 13:09:08 -05:00
Scott McMurray
348a25044b Intra-doc links apparently don't like pointers? 2021-11-22 02:40:56 -08:00
Scott McMurray
875e01e616 Add <*{const|mut} T>::{to|from}_bits
Named based on the floating-point methods of the same name, as those are also about returning the *representation* of the value.
2021-11-22 02:08:59 -08:00
Eduardo Sánchez Muñoz
23637e20cd libcore: assume the input of next_code_point and next_code_point_reverse is UTF-8-like
The functions are now `unsafe` and they use `Option::unwrap_unchecked` instead of `unwrap_or_0`

`unwrap_or_0` was added in 42357d772b. I guess `unwrap_unchecked` was not available back then.

Given this example:

```rust
pub fn first_char(s: &str) -> Option<char> {
    s.chars().next()
}
```

Previously, the following assembly was produced:

```asm
_ZN7example10first_char17ha056ddea6bafad1cE:
	.cfi_startproc
	test	rsi, rsi
	je	.LBB0_1
	movzx	edx, byte ptr [rdi]
	test	dl, dl
	js	.LBB0_3
	mov	eax, edx
	ret
.LBB0_1:
	mov	eax, 1114112
	ret
.LBB0_3:
	lea	r8, [rdi + rsi]
	xor	eax, eax
	mov	r9, r8
	cmp	rsi, 1
	je	.LBB0_5
	movzx	eax, byte ptr [rdi + 1]
	add	rdi, 2
	and	eax, 63
	mov	r9, rdi
.LBB0_5:
	mov	ecx, edx
	and	ecx, 31
	cmp	dl, -33
	jbe	.LBB0_6
	cmp	r9, r8
	je	.LBB0_9
	movzx	esi, byte ptr [r9]
	add	r9, 1
	and	esi, 63
	shl	eax, 6
	or	eax, esi
	cmp	dl, -16
	jb	.LBB0_12
.LBB0_13:
	cmp	r9, r8
	je	.LBB0_14
	movzx	edx, byte ptr [r9]
	and	edx, 63
	jmp	.LBB0_16
.LBB0_6:
	shl	ecx, 6
	or	eax, ecx
	ret
.LBB0_9:
	xor	esi, esi
	mov	r9, r8
	shl	eax, 6
	or	eax, esi
	cmp	dl, -16
	jae	.LBB0_13
.LBB0_12:
	shl	ecx, 12
	or	eax, ecx
	ret
.LBB0_14:
	xor	edx, edx
.LBB0_16:
	and	ecx, 7
	shl	ecx, 18
	shl	eax, 6
	or	eax, ecx
	or	eax, edx
	ret
```

After this change, the assembly is reduced to:

```asm
_ZN7example10first_char17h4318683472f884ccE:
	.cfi_startproc
	test	rsi, rsi
	je	.LBB0_1
	movzx	ecx, byte ptr [rdi]
	test	cl, cl
	js	.LBB0_3
	mov	eax, ecx
	ret
.LBB0_1:
	mov	eax, 1114112
	ret
.LBB0_3:
	mov	eax, ecx
	and	eax, 31
	movzx	esi, byte ptr [rdi + 1]
	and	esi, 63
	cmp	cl, -33
	jbe	.LBB0_4
	movzx	edx, byte ptr [rdi + 2]
	shl	esi, 6
	and	edx, 63
	or	edx, esi
	cmp	cl, -16
	jb	.LBB0_7
	movzx	ecx, byte ptr [rdi + 3]
	and	eax, 7
	shl	eax, 18
	shl	edx, 6
	and	ecx, 63
	or	ecx, edx
	or	eax, ecx
	ret
.LBB0_4:
	shl	eax, 6
	or	eax, esi
	ret
.LBB0_7:
	shl	eax, 12
	or	eax, edx
	ret
```
2021-11-21 17:05:55 +01:00
Jonas Platte
64cca297cb
Fix method name reference in stream documentation 2021-11-21 11:57:38 +01:00
Matthias Krüger
789d168e13
Rollup merge of #91008 - Urgau:float-minimum-maximum, r=scottmcm
Adds IEEE 754-2019 minimun and maximum functions for f32/f64

IEEE 754-2019 removed the `minNum` (`min` in Rust) and `maxNum` (`max` in Rust) operations in favor of the newly created `minimum` and `maximum` operations due to their [non-associativity](https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf) that cannot be fix in a backwards compatible manner. This PR adds `fN::{minimun,maximum}` functions following the new rules.

### IEEE 754-2019 Rules

> **minimum(x, y)** is x if x < y, y if y < x, and a quiet NaN if either operand is a NaN, according to 6.2.
For this operation, −0 compares less than +0. Otherwise (i.e., when x = y and signs are the same)
it is either x or y.

> **maximum(x, y)** is x if x > y, y if y > x, and a quiet NaN if either operand is a NaN, according to 6.2.
For this operation, +0 compares greater than −0. Otherwise (i.e., when x = y and signs are the
same) it is either x or y.

"IEEE Standard for Floating-Point Arithmetic," in IEEE Std 754-2019 (Revision of IEEE 754-2008) , vol., no., pp.1-84, 22 July 2019, doi: 10.1109/IEEESTD.2019.8766229.

### Implementation

This implementation is inspired by the one in [`glibc` ](90f0ac10a7/math/s_fminimum_template.c) (it self derived from the C2X draft) expect that:
 - it doesn't use `copysign` because it's not available in `core` and also because `copysign` is unnecessary (we only want to check the sign, no need to create a new float)
 - it also prefer `other > self` instead of `self < other` like IEEE 754-2019 does

I originally tried to implement them [using intrinsics](1d8aa13bc3) but LLVM [error out](https://godbolt.org/z/7sMrxW49a) when trying to lower them to machine intructions, GCC doesn't yet have built-ins for them, only cranelift support them nativelly (as it doesn't support the nativelly the old sementics).

Helps with https://github.com/rust-lang/rust/issues/83984
2021-11-21 09:55:13 +01:00
Linda_pp
ac083c6b45
Reborrow mut slice instead of converting it with as_ref
Co-authored-by: Noah Lev <camelidcamel@gmail.com>
2021-11-21 11:01:31 +09:00
Ibraheem Ahmed
25271a5a98 fix doc links for downcast_unchecked 2021-11-20 18:22:05 -05:00
Urgau
e2ec3b1dd7
Apply documentation suggestions from @est31
Co-authored-by: est31 <est31@users.noreply.github.com>
2021-11-20 23:05:30 +01:00
Dylan MacKenzie
7ba4accfbf Stabilize ControlFlow::{is_break, is_continue} 2021-11-20 11:52:09 -08:00
Linda_pp
66e0523d09
Update version in stable attribute
Co-authored-by: Joshua Nelson <github@jyn.dev>
2021-11-20 23:35:28 +09:00
rhysd
72b411fd89 Implement TryFrom<&'_ mut [T]> for [T; N] 2021-11-20 23:05:08 +09:00
Loïc BRANSTETT
2bad893900 Add similar note as LLVM does for minNum and maxNum functions 2021-11-20 10:14:03 +01:00
Loïc BRANSTETT
a8ee0e9c2c Implement IEEE 754-2019 minimun and maximum functions for f32/f64 2021-11-20 10:14:03 +01:00
Matthias Krüger
62b259cd88
Rollup merge of #91044 - r00ster91:x1b, r=joshtriplett
Turn all 0x1b_u8 into '\x1b' or b'\x1b'

Supersedes #91040
2021-11-20 01:09:44 +01:00
Matthias Krüger
97bd45b373
Rollup merge of #88361 - WaffleLapkin:patch-2, r=jyn514
Makes docs for references a little less confusing

- Make clear that the `Pointer` trait is related to formatting
- Make clear that the `Pointer` trait is implemented for references (previously it was confusing to first see that it's implemented and then see it in "expect")
- Make clear that `&T` (shared reference) implements `Send` (if `T: Send + Sync`)
2021-11-20 01:09:37 +01:00
r00ster91
a2d78573d3 Turn all 0x1b_u8 into '\x1b' or b'\x1b' 2021-11-19 18:14:18 +01:00
Maybe Waffle
cdb0c29a9c Remove unnecessary doc links 2021-11-19 19:13:53 +03:00
The8472
3f9b26dc64 Fix Iterator::advance_by contract inconsistency
The `advance_by(n)` docs state that in the error case `Err(k)` that k is always less than n.
It also states that `advance_by(0)` may return `Err(0)` to indicate an exhausted iterator.
These statements are inconsistent.
Since only one implementation (Skip) actually made use of that I changed it to return Ok(()) in that case too.

While adding some tests I also found a bug in `Take::advance_back_by`.
2021-11-19 13:00:23 +01:00
Yuki Okushi
7432588e5d
Rollup merge of #89258 - est31:const_char_convert, r=oli-obk
Make char conversion functions unstably const

The char conversion functions like `char::from_u32` do trivial computations and can easily be converted into const fns. Only smaller tricks are needed to avoid non-const standard library functions like `Result::ok` or `bool::then_some`.

Tracking issue: https://github.com/rust-lang/rust/issues/89259
2021-11-19 13:06:31 +09:00
bors
cc946fcd32 Auto merge of #91019 - JohnTitor:rollup-q95ra7r, r=JohnTitor
Rollup of 8 pull requests

Successful merges:

 - #90386 (Add `-Zassert-incr-state` to assert state of incremental cache)
 - #90438 (Clean up mess for --show-coverage documentation)
 - #90480 (Mention `Vec::remove` in `Vec::swap_remove`'s docs)
 - #90607 (Make slice->str conversion and related functions `const`)
 - #90750 (rustdoc: Replace where-bounded Clean impl with simple function)
 - #90895 (require full validity when determining the discriminant of a value)
 - #90989 (Avoid suggesting literal formatting that turns into member access)
 - #91002 (rustc: Remove `#[rustc_synthetic]`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
2021-11-18 20:23:26 +00:00
bors
b6f580acc0 Auto merge of #90382 - alexcrichton:wasm64-libstd, r=joshtriplett
std: Get the standard library compiling for wasm64

This commit goes through and updates various `#[cfg]` as appropriate to
get the wasm64-unknown-unknown target behaving similarly to the
wasm32-unknown-unknown target. Most of this is just updating various
conditions for `target_arch = "wasm32"` to also account for `target_arch
= "wasm64"` where appropriate. This commit also lists `wasm64` as an
allow-listed architecture to not have the `restricted_std` feature
enabled, enabling experimentation with `-Z build-std` externally.

The main goal of this commit is to enable playing around with
`wasm64-unknown-unknown` externally via `-Z build-std` in a way that's
similar to the `wasm32-unknown-unknown` target. These targets are
effectively the same and only differ in their pointer size, but wasm64
is much newer and has much less ecosystem/library support so it'll still
take time to get wasm64 fully-fledged.
2021-11-18 17:19:27 +00:00
Maybe Waffle
573a00e3f9 Fill in tracking issues for const_str_from_utf8 and const_str_from_utf8_unchecked_mut features 2021-11-18 14:04:01 +03:00
The8472
fd1494e9c3 Document non-guarantees for Hash
Dependence on endianness and type sizes was reported for enum discriminants in #74215 but it is a more general
issue since for example the default implementation of `Hasher::write_usize` uses native endianness.
Additionally the implementations of library types are occasionally changed as their internal fields
change or hashing gets optimized.
2021-11-18 02:00:53 +01:00
Maybe Waffle
cf6f64a963 Make slice->str conversion and related functions const
This commit makes the following functions from `core::str` `const fn`:
- `from_utf8[_mut]` (`feature(const_str_from_utf8)`)
- `from_utf8_unchecked_mut` (`feature(const_str_from_utf8_unchecked_mut)`)
- `Utf8Error::{valid_up_to,error_len}` (`feature(const_str_from_utf8)`)
2021-11-18 00:50:42 +03:00
Matthias Krüger
ec84633b54
Rollup merge of #90687 - jhpratt:const_panic, r=oli-obk
Permit const panics in stable const contexts in stdlib

Without this change, it is not possible to use `panic!` and similar (including `assert!`) in stable const contexts inside of stdlib. See #89542 for a real-world case that currently fails for this reason. This does _not_ affect any user code.

For example, this snippet currently fails to compile:

```rust
#[stable(feature = "foo", since = "1.0.0")]
#[rustc_const_stable(feature = "foo", since = "1.0.0")]
const fn foo() {
    assert!(false);
    assert!(false, "foo");
}
```

With the addition of `#[rustc_const_unstable]` to `core::panicking::panic`, the error no longer occurs. This snippet has been added verbatim in this PR as a UI test.

To avoid needing to add `#![feature(core_panic)]` to libcore, the two instances of direct calls to `core::panicking::panic` have been switched to use the `panic!` macro.

I am requesting prioritization because this is holding up other stabilizations such as #89542 (which is otherwise ready to merge and succeeds with this change)
2021-11-17 15:58:00 +01:00
Maybe Waffle
f926c0e0d9 Fill in tracking issue for feature const_align_offset 2021-11-16 23:58:40 +03:00
Maybe Waffle
8f5f094432 Mark <*const _>::align_offset and <*mut _>::align_offset as const fn 2021-11-16 23:03:28 +03:00
Yuki Okushi
35dd1f65e9
Rollup merge of #90909 - RalfJung:miri-no-portable-simd, r=workingjubilee
disable portable SIMD tests in Miri

Until https://github.com/rust-lang/miri/issues/1912 is resolved, we'll have to skip these tests in Miri.
2021-11-16 09:14:23 +09:00
Yuki Okushi
fb96ecc37a
Rollup merge of #90848 - scottmcm:remove-signed-bigint-helpers, r=joshtriplett
Remove bigint_helper_methods for *signed* types

This PR inspired by `@cuviper's` comment @ https://github.com/rust-lang/rust/issues/90541#issuecomment-967309808

These are working well for *unsigned* types, so keep those, but for the the *signed* ones there are a bunch of questions about what the semantics and API should be.  For the main "helpers for big integer implementations" use, there's no need for the signed versions anyway.  There are plenty of other methods which exist for unsigned types but not signed ones, like `next_power_of_two`, so this isn't unusual.

Fixes #90541
Tracking issue #85532
2021-11-16 09:14:21 +09:00
bors
891ca5f63c Auto merge of #90821 - scottmcm:new-slice-reverse, r=Mark-Simulacrum
MIRI says `reverse` is UB, so replace it with something LLVM can vectorize

For small types with padding, the current implementation is UB because it does integer operations on uninit values.
```
error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
   --> /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/num/mod.rs:836:5
    |
836 | /     uint_impl! { u32, u32, i32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
837 | |     "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "", "" }
    | |________________________________________________________________________________________________^ using uninitialized data, but this operation requires initialized memory
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

    = note: inside `core::num::<impl u32>::rotate_left` at /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/num/uint_macros.rs:211:13
    = note: inside `core::slice::<impl [Foo]>::reverse` at /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/slice/mod.rs:701:58
```
<https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=340739f22ca5b457e1da6f361768edc6>

But LLVM has gotten smarter since I wrote the previous implementation in 2017, so this PR removes all the manual magic and just writes it in such a way that LLVM will vectorize.  This code is much simpler and has very little `unsafe`, and is actually faster to boot!

If you're curious to see the codegen: <https://rust.godbolt.org/z/Pcn13Y9E3>

Before:
```
running 7 tests
test slice::reverse_simd_f64x4                           ... bench:      17,940 ns/iter (+/- 481) = 58448 MB/s
test slice::reverse_u128                                 ... bench:      17,758 ns/iter (+/- 205) = 59048 MB/s
test slice::reverse_u16                                  ... bench:     158,234 ns/iter (+/- 6,876) = 6626 MB/s
test slice::reverse_u32                                  ... bench:      62,047 ns/iter (+/- 1,117) = 16899 MB/s
test slice::reverse_u64                                  ... bench:      31,582 ns/iter (+/- 552) = 33201 MB/s
test slice::reverse_u8                                   ... bench:      81,253 ns/iter (+/- 1,510) = 12905 MB/s
test slice::reverse_u8x3                                 ... bench:     270,615 ns/iter (+/- 11,463) = 3874 MB/s
```

After:
```
running 7 tests
test slice::reverse_simd_f64x4                           ... bench:      17,731 ns/iter (+/- 306) = 59137 MB/s
test slice::reverse_u128                                 ... bench:      17,919 ns/iter (+/- 239) = 58517 MB/s
test slice::reverse_u16                                  ... bench:      43,160 ns/iter (+/- 607) = 24295 MB/s
test slice::reverse_u32                                  ... bench:      21,065 ns/iter (+/- 371) = 49778 MB/s
test slice::reverse_u64                                  ... bench:      21,118 ns/iter (+/- 482) = 49653 MB/s
test slice::reverse_u8                                   ... bench:      76,878 ns/iter (+/- 1,688) = 13639 MB/s
test slice::reverse_u8x3                                 ... bench:     264,723 ns/iter (+/- 5,544) = 3961 MB/s
```

Those are the existing benches, <14a2fd640e/library/alloc/benches/slice.rs (L322-L346)>
2021-11-15 20:19:23 +00:00
Ralf Jung
60595f7bde disable portable SIMD tests in Miri 2021-11-14 12:26:35 -05:00
Jacob Pratt
5907a8ca10
Fix incorrect feature flags 2021-11-14 00:53:09 -05:00
bors
d212d902ae Auto merge of #89551 - jhpratt:stabilize-const_raw_ptr_deref, r=oli-obk
Stabilize `const_raw_ptr_deref` for `*const T`

This stabilizes dereferencing immutable raw pointers in const contexts.
It does not stabilize `*mut T` dereferencing. This is behind the
same feature gate as mutable references.

closes https://github.com/rust-lang/rust/issues/51911
2021-11-13 17:10:15 +00:00
bors
7594067b69 Auto merge of #90041 - jfrimmel:rt_copy_checks, r=Mark-Simulacrum
Re-enable `copy[_nonoverlapping]()` debug-checks

This commit re-enables the debug checks for valid usages of the two functions `copy()` and `copy_nonoverlapping()`. Those checks were commented out in #79684 in order to make the functions const. All that's been left was a FIXME, that could not be resolved until there is was way to only do the checks at runtime.
Since #89247 there is such a way: `const_eval_select()`. This commit uses that new intrinsic in order to either do nothing (at compile time) or to do the old checks (at runtime).

The change itself is rather small: in order to make the checks usable with `const_eval_select`, they are moved into a local function (one for `copy` and one for `copy_nonoverlapping` to keep symmetry).

The change does not break referential transparency, as there is nothing you can do at compile time, which you cannot do on runtime without getting undefined behavior. The CTFE-engine won't allow missuses. The other way round is also fine.

I've refactored the code to use `#[cfg(debug_assertions)]` on the new items. If that is not desired, the second commit can be dropped.
I haven't added any checks, as I currently don't know, how to test this properly.

Closes #90012.

cc `@rust-lang/lang,` `@rust-lang/libs` and `@rust-lang/wg-const-eval` (as those teams are linked in the issue above).
2021-11-13 05:19:39 +00:00
Ibraheem Ahmed
8db85a3c78 add slice take methods 2021-11-12 23:08:27 -05:00
Ibraheem Ahmed
6f982930ba add tracking issue for downcast_unchecked 2021-11-12 22:55:11 -05:00
Ibraheem Ahmed
29403eeef0 add unchecked downcast methods 2021-11-12 22:53:26 -05:00
bors
032dfe4360 Auto merge of #89167 - workingjubilee:use-simd, r=MarkSimulacrum
pub use core::simd;

A portable abstraction over SIMD has been a major pursuit in recent years for several programming languages. In Rust, `std::arch` offers explicit SIMD acceleration via compiler intrinsics, but it does so at the cost of having to individually maintain each and every single such API, and is almost completely `unsafe` to use.  `core::simd` offers safe abstractions that are resolved to the appropriate SIMD instructions by LLVM during compilation, including scalar instructions if that is all that is available.

`core::simd` is enabled by the `#![portable_simd]` nightly feature tracked in https://github.com/rust-lang/rust/issues/86656 and is introduced here by pulling in the https://github.com/rust-lang/portable-simd repository as a subtree. We built the repository out-of-tree to allow faster compilation and a stochastic test suite backed by the proptest crate to verify that different targets, features, and optimizations produce the same result, so that using this library does not introduce any surprises. As these tests are technically non-deterministic, and thus can introduce overly interesting Heisenbugs if included in the rustc CI, they are visible in the commit history of the subtree but do nothing here. Some tests **are** introduced via the documentation, but these use deterministic asserts.

There are multiple unsolved problems with the library at the current moment, including a want for better documentation, technical issues with LLVM scalarizing and lowering to libm, room for improvement for the APIs, and so far I have not added the necessary plumbing for allowing the more experimental or libm-dependent APIs to be used. However, I thought it would be prudent to open this for review in its current condition, as it is both usable and it is likely I am going to learn something else needs to be fixed when bors tries this out.

The major types are
- `core::simd::Simd<T, N>`
- `core::simd::Mask<T, N>`

There is also the `LaneCount` struct, which, together with the SimdElement and SupportedLaneCount traits, limit the implementation's maximum support to vectors we know will actually compile and provide supporting logic for bitmasks. I'm hoping to simplify at least some of these out of the way as the compiler and library evolve.
2021-11-13 02:17:20 +00:00
Scott McMurray
6323f928bf Remove bigint_helper_methods for *signed* types
These are working well for *unsigned* types, for the the signed ones there are a bunch of questions about what the semantics and API should be.  And for the main "helpers for big integer implementations" use, there's no need for the signed versions anyway.

And there are plenty of other methods which exist for unsigned types but not signed ones, like `next_power_of_two`, so this isn't unusual.

Fixes 90541
2021-11-12 17:00:47 -08:00
Jubilee Young
7c3d72d069 Test core::simd works
These tests just verify some basic APIs of core::simd function, and
guarantees that attempting to access the wrong things doesn't work.
The majority of tests are stochastic, and so remain upstream, but
a few deterministic tests arrive in the subtree as doc tests.
2021-11-12 16:58:47 -08:00
Jubilee Young
39cb863253 Expose portable-simd as core::simd
This enables programmers to use a safe alternative to the current
`extern "platform-intrinsics"` API for writing portable SIMD code.
This is `#![feature(portable_simd)]` as tracked in #86656
2021-11-12 16:58:39 -08:00
Matthias Krüger
5b3cb68d97
Rollup merge of #90798 - edmorley:doc-unreachable-custom-message, r=dtolnay
Document `unreachable!` custom panic message

The `unreachable!` docs previously did not mention that there was a second form, `unreachable!("message")` that could be used to specify a custom panic message,

The docs now mention this feature in the same wording as currently used for `unimplemented!`:
https://doc.rust-lang.org/core/macro.unimplemented.html#panics
2021-11-12 19:17:33 +01:00
Matthias Krüger
70532c4503
Rollup merge of #90644 - est31:const_swap, r=Mark-Simulacrum
Extend the const swap feature

Adds the `const_swap` feature gate to three more swap functions. cc tracking issue #83163

```Rust
impl<T> [T] {
    pub const fn swap(&mut self, a: usize, b: usize);
    pub const unsafe fn swap_unchecked(&mut self, a: usize, b: usize);
}
impl<T: ?Sized> *mut T {
    pub const unsafe fn swap(self, with: *mut T);
}
2021-11-12 19:17:30 +01:00
Scott McMurray
71f5cfb21f MIRI says reverse is UB, so replace it with an implementation that LLVM can vectorize
For small types with padding, the current implementation is UB because it does integer operations on uninit values.  But LLVM has gotten smarter since I wrote the previous implementation in 2017, so remove all the manual magic and just write it in such a way that LLVM will vectorize.  This code is much simpler (albeit nuanced) and has very little `unsafe`, and is actually faster to boot!
2021-11-11 20:32:18 -08:00
Ed Morley
b41b2e5a5c
Document unreachable!() custom panic message
The `unreachable!` docs previously did not mention that there was a second
form, `unreachable!("message")` that could be used to specify a custom panic
message,

The docs now mention this in the same style as currently used for `unimplemented!`:
https://doc.rust-lang.org/core/macro.unimplemented.html#panics
2021-11-11 13:41:21 +00:00
Scott McMurray
5b115fcb68 Moar #[inline] 2021-11-10 11:57:14 -08:00
Alex Crichton
971638824f Use target_family = "wasm" 2021-11-10 08:35:42 -08:00
Alex Crichton
7f3ffbc8c2 std: Get the standard library compiling for wasm64
This commit goes through and updates various `#[cfg]` as appropriate to
get the wasm64-unknown-unknown target behaving similarly to the
wasm32-unknown-unknown target. Most of this is just updating various
conditions for `target_arch = "wasm32"` to also account for `target_arch
= "wasm64"` where appropriate. This commit also lists `wasm64` as an
allow-listed architecture to not have the `restricted_std` feature
enabled, enabling experimentation with `-Z build-std` externally.

The main goal of this commit is to enable playing around with
`wasm64-unknown-unknown` externally via `-Z build-std` in a way that's
similar to the `wasm32-unknown-unknown` target. These targets are
effectively the same and only differ in their pointer size, but wasm64
is much newer and has much less ecosystem/library support so it'll still
take time to get wasm64 fully-fledged.
2021-11-10 08:35:42 -08:00
Scott McMurray
cc7d8014d7 Specialize array cloning for Copy types
Because after PR 86041, the optimizer no longer load-merges at the LLVM IR level, which might be part of the perf loss.  (I'll run perf and see if this makes a difference.)

Also I added a codegen test so this hopefully won't regress in future -- it passes on stable and with my change here, but not on the 2021-11-09 nightly.
2021-11-09 21:43:20 -08:00
mbartlett21
8b81937f9a
Format 2021-11-10 09:05:15 +10:00
mbartlett21
9de2745c95
Rename Option::cloned gate 2021-11-10 08:46:35 +10:00
mbartlett21
afdec886f3
Make Option::cloned const fn. 2021-11-10 08:41:01 +10:00
est31
eeaa2f16aa Extend the const_swap feature
This makes the inherent method ptr::swap unstably
const, as well as slice::swap{,_unchecked}.
2021-11-09 20:09:56 +01:00
bors
d6082292a6 Auto merge of #86041 - bstrie:unmagic-array-copy, r=jackh726
Replace Copy/Clone compiler magic on arrays with library impls

With const generics the compiler no longer needs to fake these impls.
2021-11-09 17:13:44 +00:00
Julian Frimmel
60a9d5a5a9 Re-enable copy[_nonoverlapping]() runtime checks
This commit re-enables the debug checks for valid usages of the two
functions `copy()` and `copy_nonoverlapping()`. Those checks were com-
mented out in #79684 in order to make the functions const. All that's
been left was a FIXME, that could not be resolved until there is was way
to only do the checks at runtime.
Since #89247 there is such a way: `const_eval_select()`. This commit
uses that new intrinsic in order to either do nothing (at compile time)
or to do the old checks (at runtime).

The change itself is rather small: in order to make the checks usable
with `const_eval_select`, they are moved into a local function (one for
`copy` and one for `copy_nonoverlapping` to keep symmetry).

The change does not break referential transparency, as there is nothing
you can do at compile time, which you cannot do on runtime without get-
ting undefined behavior. The CTFE-engine won't allow missuses. The other
way round is also fine.
2021-11-09 10:02:09 +01:00
Jacob Pratt
6d2f8af1db
Permit const assertions in stdlib 2021-11-08 17:06:00 -05:00
bstrie
61b1394ac7 Attempt to address perf regressions with #[inline] 2021-11-08 15:51:56 -05:00
bstrie
3024efff59 Update Copy/Clone documentation WRT arrays 2021-11-08 13:11:59 -05:00
bstrie
ce1143e94d impl Copy/Clone for arrays in std, not in compiler 2021-11-08 13:11:58 -05:00
bstrie
86c0ef8adc Add comments regarding superfluous !Sync impls 2021-11-08 13:07:20 -05:00
bors
90a273b785 Auto merge of #90348 - Amanieu:asm_feature_gates, r=joshtriplett
Add features gates for experimental asm features

This PR splits off parts of `asm!` into separate features because they are not ready for stabilization.

Specifically this adds:
- `asm_const` for `const` operands.
- `asm_sym` for `sym` operands.
- `asm_experimental_arch` for architectures other than x86, x86_64, arm, aarch64 and riscv.

r? `@nagisa`
2021-11-07 04:59:42 +00:00
Amanieu d'Antras
eb32c00216 Add features gates for experimental asm features 2021-11-07 01:23:53 +00:00
Jacob Pratt
0cdbeaa2a3
Stabilize const_raw_ptr_deref for *const T
This stabilizes dereferencing immutable raw pointers in const contexts.
It does not stabilize `*mut T` dereferencing. This is placed behind the
`const_raw_mut_ptr_deref` feature gate.
2021-11-06 17:05:15 -04:00
Yuki Okushi
0b3a002805
Reorder widening_impls to make the doc clearer 2021-11-05 11:55:51 -07:00
Scott McMurray
dc2c2603c6 Add more text and examples to `carrying_{add|mul}" 2021-11-04 00:51:45 -07:00
bors
c7e4740ec1 Auto merge of #86336 - camsteffen:char-array-pattern, r=joshtriplett
impl Pattern for char array

Closes #39511
Closes #86329
2021-10-31 15:45:39 +00:00
Matthias Krüger
88e5ae2dd3
Rollup merge of #89786 - jkugelman:must-use-len-and-is_empty, r=joshtriplett
Add #[must_use] to len and is_empty

Parent issue: #89692

r? `@joshtriplett`
2021-10-31 13:20:05 +01:00
Matthias Krüger
d4bdcdb1ec
Rollup merge of #89951 - ojeda:stable-unwrap_unchecked, r=dtolnay
Stabilize `option_result_unwrap_unchecked`

Closes https://github.com/rust-lang/rust/issues/81383.

Stabilization report: https://github.com/rust-lang/rust/issues/81383#issuecomment-944498212.

```@rustbot``` label +A-option-result +T-libs-api
2021-10-31 09:20:27 +01:00
Matthias Krüger
95750ae439
Rollup merge of #89897 - jkugelman:must-use-core, r=joshtriplett
Add #[must_use] to remaining core functions

I've run out of compelling reasons to group functions together across crates so I'm just going to go module-by-module. This is everything remaining from the `core` crate.

Ignored by clippy for reasons unknown:

```rust
core::alloc::Layout   unsafe fn for_value_raw<T: ?Sized>(t: *const T) -> Self;
core::any             const fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str;
```

Ignored by clippy because of `mut`:

```rust
str   fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str);
```

<del>
Ignored by clippy presumably because a caller might want `f` called for side effects. That seems like a bad usage of `map` to me.

```rust
core::cell::Ref<'b, T>   fn map<U: ?Sized, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, T>;
core::cell::Ref<'b, T>   fn map_split<U: ?Sized, V: ?Sized, F>(orig: Ref<'b, T>, f: F) -> (Ref<'b, U>, Ref<'b, V>);
```
</del>

Parent issue: #89692

r? ```@joshtriplett```
2021-10-31 09:20:26 +01:00
Matthias Krüger
e79e9f5e2a
Rollup merge of #89839 - jkugelman:must-use-mem-ptr-functions, r=joshtriplett
Add #[must_use] to mem/ptr functions

There's a lot of low-level / unsafe stuff here. Are there legit use cases for ignoring any of these return values?

* No regressions in `./x.py test --stage 1 library/std src/tools/clippy`.
* One regression in `./x.py test --stage 1 src/test/ui`. Fixed.
* I am unable to run `./x.py doc` on my machine so I'll need to wait for the CI to verify doctests pass. I eyeballed all the adjacent tests and they all look okay.

Parent issue: #89692

r? ```@joshtriplett```
2021-10-31 09:20:25 +01:00
Matthias Krüger
a26b1d2259
Rollup merge of #89835 - jkugelman:must-use-expensive-computations, r=joshtriplett
Add #[must_use] to expensive computations

The unifying theme for this commit is weak, admittedly. I put together a list of "expensive" functions when I originally proposed this whole effort, but nobody's cared about that criterion. Still, it's a decent way to bite off a not-too-big chunk of work.

Given the grab bag nature of this commit, the messages I used vary quite a bit. I'm open to wording changes.

For some reason clippy flagged four `BTreeSet` methods but didn't say boo about equivalent ones on `HashSet`. I stared at them for a while but I can't figure out the difference so I added the `HashSet` ones in.

```rust
// Flagged by clippy.
alloc::collections::btree_set::BTreeSet<T>   fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T>;
alloc::collections::btree_set::BTreeSet<T>   fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T>
alloc::collections::btree_set::BTreeSet<T>   fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T>;
alloc::collections::btree_set::BTreeSet<T>   fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T>;

// Ignored by clippy, but not by me.
std::collections::HashSet<T, S>              fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S>;
std::collections::HashSet<T, S>              fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, S>) -> SymmetricDifference<'a, T, S>
std::collections::HashSet<T, S>              fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S>;
std::collections::HashSet<T, S>              fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S>;
```

Parent issue: #89692

r? ```@joshtriplett```
2021-10-31 09:20:24 +01:00
Matthias Krüger
e7be8a2c07
Rollup merge of #89446 - chrismit3s:issue-88715-fix, r=joshtriplett
Add paragraph to ControlFlow docs to menion it works with the ? operator (#88715)

fixes #88715

r? ```@steveklabnik```
2021-10-31 09:20:21 +01:00
bors
0a09858b05 Auto merge of #90306 - kornelski:slicecloneasset, r=joshtriplett
track_caller for slice length assertions

`clone_from_slice` was missing `#[track_caller]`, and its assert did not report a useful location.

These are small generic methods, so hopefully track_caller gets inlined into nothingness, but it may be worth running a benchmark on this.
2021-10-31 01:56:40 +00:00
John Kugelman
6745e8da06 Add #[must_use] to len and is_empty 2021-10-30 19:25:12 -04:00
John Kugelman
887503ad14 Add #[must_use] to mem/ptr functions 2021-10-30 18:54:48 -04:00
John Kugelman
68b0d86294 Add #[must_use] to remaining core functions 2021-10-30 18:21:29 -04:00
Matthias Krüger
b531364a1a
Rollup merge of #90377 - WaffleLapkin:const_slice_from_raw_parts, r=oli-obk
Make `core::slice::from_raw_parts[_mut]` const

Responses to #90012 seem to allow ``@rust-lang/wg-const-eval`` to decide on use of `const_eval_select`, so we can make `core::slice::from_raw_parts[_mut]` const :)

---
This PR marks the following APIs as const:
```rust
// core::slice
pub const unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T];
pub const unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T];
```
---

Resolves #90011
r? ``@oli-obk``
2021-10-30 14:37:01 +02:00
Matthias Krüger
86087f906d
Rollup merge of #90371 - Veykril:patch-2, r=jyn514
Fix incorrect doc link

Looks like a copy paste mistake
2021-10-30 14:36:59 +02:00
Matthias Krüger
20bb93210d
Rollup merge of #89876 - AlexApps99:const_ops, r=oli-obk
Make most std::ops traits const on numeric types

This PR makes existing implementations of `std::ops` traits (`Add`, `Sub`, etc) [`impl const`](https://github.com/rust-lang/rust/issues/67792) where possible.
This affects:
- All numeric primitives (`u*`, `i*`, `f*`)
- `NonZero*`
- `Wrapping`

This is under the `rustc_const_unstable` feature `const_ops`.
I will write tests once I know what can and can't be kept for the final version of this PR.

Since this is my first PR to rustc (and hopefully one of many), please give me feedback on how to better handle the PR process wherever possible. Thanks

[Zulip discussion](https://rust-lang.zulipchat.com/#narrow/stream/219381-t-libs/topic/Const.20std.3A.3Aops.20traits.20PR)
2021-10-30 14:36:58 +02:00
bors
6d42707cde Auto merge of #90346 - ferrocene:pa-short-circuit, r=oli-obk
Replace some operators in libcore with their short-circuiting equivalents

In libcore there are a few occurrences of bitwise operators used in boolean expressions instead of their short-circuiting equivalents. This makes it harder to perform some kinds of source code analysis over libcore, for example [MC/DC] code coverage (a requirement in safety-critical environments).

This PR aims to remove as many bitwise operators in boolean expressions from libcore as possible, without any performance regression and without other changes. This means not all bitwise operators are removed, only the ones that don't have any difference with their short-circuiting counterparts. This already simplifies achieving MC/DC coverage, and the other functions can be changed in future PRs.

The PR is best reviewed commit-by-commit, and each commit has the resulting assembly in the message.

## Checked integer methods

These methods recently switched to bitwise operators in PRs https://github.com/rust-lang/rust/pull/89459 and https://github.com/rust-lang/rust/pull/89351. I confirmed bitwise operators are needed in most of the functions, except these two:

* `{integer}::checked_div` ([Godbolt link (nightly)](https://rust.godbolt.org/z/17efh5jPc))
* `{integer}::checked_rem` ([Godbolt link (nightly)](https://rust.godbolt.org/z/85qGWc94K))

`@tspiteri` already mentioned this was the case in https://github.com/rust-lang/rust/pull/89459#issuecomment-932728384, but opted to also switch those two to bitwise operators for consistency. As that makes MC/DC analysis harder this PR proposes switching those two back to short-circuiting operators.

## `{unsigned_ints}::carrying_add`

[Godbolt link (1.56.0)](https://rust.godbolt.org/z/vG9vx8x48)

In this instance replacing the `|` with `||` produces the exact same assembly when optimizations are enabled, so switching to the short-circuiting operator shouldn't have any impact.

## `{unsigned_ints}::borrowing_sub`

[Godbolt link (1.56.0)](https://rust.godbolt.org/z/asEfKaGE4)

In this instance replacing the `|` with `||` produces the exact same assembly when optimizations are enabled, so switching to the short-circuiting operator shouldn't have any impact.

## String UTF-8 validation

[Godbolt link (1.56.0)](https://rust.godbolt.org/z/a4rEbTvvx)

In this instance replacing the `|` with `||` produces practically the same assembly, with the two operands for the "or" swapped:

```asm
; Old
mov  rax, qword ptr [rdi + rdx + 8]
or   rax, qword ptr [rdi + rdx]
test rax, r9
je   .LBB0_7

; New
mov  rax, qword ptr [rdi + rdx]
or   rax, qword ptr [rdi + rdx + 8]
test rax, r8
je   .LBB0_7
```

[MC/DC]: https://en.wikipedia.org/wiki/Modified_condition/decision_coverage
2021-10-29 21:50:46 +00:00
Maybe Waffle
afaa54a99d Apply changes proposed in the review 2021-10-29 23:45:09 +03:00
Maybe Waffle
878ac10fe1 Use proper issue number for feature(const_slice_from_raw_parts) 2021-10-29 22:45:10 +03:00
Matthias Krüger
ae244d8b78
Rollup merge of #90336 - mbartlett21:patch-4, r=Mark-Simulacrum
Remove extra lines in examples for `Duration::try_from_secs_*`

None of the other examples have extra lines below the `#![feature(...)]` statements, so I thought it appropriate that these examples shouldn't either.
2021-10-29 00:30:30 +02:00
Maybe Waffle
991a296ce7 Make core::slice::from_raw_parts[_mut] const 2021-10-28 17:15:25 +03:00
Lukas Wirth
29a4e4a009
Fix incorrect doc link 2021-10-28 11:51:00 +02:00
bors
dd757b9e06 Auto merge of #90273 - nbdd0121:const, r=fee1-dead
Clean up special function const checks

Mark them as const and `#[rustc_do_not_const_check]` instead of hard-coding them in const-eval checks.

r? `@oli-obk`
`@rustbot` label A-const-eval T-compiler
2021-10-27 15:32:42 +00:00
Pietro Albini
68a4460b61
replace & with && in {integer}::checked_rem
Using short-circuit operators makes it easier to perform some kinds of
source code analysis, like MC/DC code coverage (a requirement in
safety-critical environments). The optimized x86 assembly is the same
between the old and new versions:

```
xor eax, eax
test esi, esi
je .LBB0_1
cmp edi, -2147483648
jne .LBB0_4
cmp esi, -1
jne .LBB0_4
ret
.LBB0_1:
ret
.LBB0_4:
mov eax, edi
cdq
idiv esi
mov eax, 1
ret
```
2021-10-27 17:01:05 +02:00
Pietro Albini
81130fe188
replace & with && in {integer}::checked_div
Using short-circuit operators makes it easier to perform some kinds of
source code analysis, like MC/DC code coverage (a requirement in
safety-critical environments). The optimized x86 assembly is the same
between the old and new versions:

```
xor eax, eax
test esi, esi
je .LBB0_1
cmp edi, -2147483648
jne .LBB0_4
cmp esi, -1
jne .LBB0_4
ret
.LBB0_1:
ret
.LBB0_4:
mov eax, edi
cdq
idiv esi
mov edx, eax
mov eax, 1
ret
```
2021-10-27 17:00:57 +02:00
Pietro Albini
a5a8bb0125
replace | with || in string validation
Using short-circuiting operators makes it easier to perform some kinds
of source code analysis, like MC/DC code coverage (a requirement in
safety-critical environments). The optimized x86_64 assembly is
equivalent between the old and new versions.

Old assembly of that condition:

```
mov  rax, qword ptr [rdi + rdx + 8]
or   rax, qword ptr [rdi + rdx]
test rax, r9
je   .LBB0_7
```

New assembly of that condition:

```
mov  rax, qword ptr [rdi + rdx]
or   rax, qword ptr [rdi + rdx + 8]
test rax, r8
je   .LBB0_7
```
2021-10-27 17:00:49 +02:00
Pietro Albini
9fb66969e3
replace | with || in {unsigned_int}::borrowing_sub
Using short-circuiting operators makes it easier to perform some kinds
of source code analysis, like MC/DC code coverage (a requirement in
safety-critical environments). The optimized x86_64 assembly is the same
between the old and new versions:

```
mov eax, edi
add dl, -1
sbb eax, esi
setb dl
ret
```
2021-10-27 17:00:46 +02:00
Pietro Albini
5913ef6660
replace | with || in {unsigned_int}::carrying_add
Using short-circuiting operators makes it easier to perform some kinds
of source code analysis, like MC/DC code coverage (a requirement in
safety-critical environments). The optimized x86_64 assembly is the same
between the old and new versions:

```
mov eax, edi
add dl, -1
adc eax, esi
setb dl
ret
```
2021-10-27 17:00:36 +02:00
Matthias Krüger
e3eebfeea6
Rollup merge of #90154 - camelid:remove-getdefid, r=jyn514
rustdoc: Remove `GetDefId`

See the individual commit messages for details.

r? `@jyn514`
2021-10-27 06:11:35 +02:00
mbartlett21
aa48de0b0e
Remove extra lines in examples for Duration::try_from_secs_* 2021-10-27 13:52:39 +10:00
Kornel
90ea93bf1a track_caller for slice length assertions 2021-10-26 13:03:02 +01:00
Matthias Krüger
14931b94a2
Rollup merge of #90196 - yanok:master, r=scottmcm
Fix and extent ControlFlow `traverse_inorder` example

Fix and extent ControlFlow `traverse_inorder` example

1. The existing example compiles on its own, but any usage fails to be monomorphised and so doesn't compile. Fix that by using Fn trait instead of FnMut.
2. Added an example usage of `traverse_inorder` showing how we can terminate the traversal early.

Fixes #90063
2021-10-25 22:59:47 +02:00
Gary Guo
cc4345a1c5 Clean up special function const checks
Mark them as const and `#[rustc_do_not_const_check]` instead of hard-coding
them in const-eval checks.
2021-10-25 17:32:01 +01:00
woppopo
7430b22b5f Make Option::expect const 2021-10-26 00:41:39 +09:00
bors
84c2a8505d Auto merge of #90265 - GuillaumeGomez:rollup-gx3ficp, r=GuillaumeGomez
Rollup of 5 pull requests

Successful merges:

 - #90017 (Add a couple tests for normalize under binder issues)
 - #90079 (enable `i8mm` target feature on aarch64 and arm)
 - #90233 (Tooltip overflow)
 - #90257 (Changed slice.swap documentation for better readability)
 - #90261 (Move back to linux builder on try builds)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
2021-10-25 14:40:45 +00:00
Tommaso Fontana
9b28ab40ac
Fixed missing double quote in the patch (slice.swap) 2021-10-25 14:13:54 +02:00
Tommaso Fontana
32a3edb153
Changed slice.swap documentation for better readability
using "b" and "d" can be easily confused
2021-10-25 13:51:34 +02:00
bors
235d9853d8 Auto merge of #90042 - pietroalbini:1.56-master, r=Mark-Simulacrum
Bump bootstrap compiler to 1.57

Fixes https://github.com/rust-lang/rust/issues/90152

r? `@Mark-Simulacrum`
2021-10-25 11:31:47 +00:00
Ilya Yanok
f3795e27c1 Fix and extend ControlFlow traverse_inorder example
1. The existing example compiles on its own, but any usage fails
   to be monomorphised and so doesn't compile. Fix that by using
   a mutable reference as an input argument.
2. Added an example usage of `traverse_inorder` showing how we
   can terminate the traversal early.

Fixes #90063
2021-10-24 20:12:22 +02:00
Matthias Krüger
c16ee19dd4
Rollup merge of #90162 - WaffleLapkin:const_array_slice_from_ref_mut, r=oli-obk
Mark `{array, slice}::{from_ref, from_mut}` as const fn

This PR marks the following APIs as `const`:
```rust
// core::array
pub const fn from_ref<T>(s: &T) -> &[T; 1];
pub const fn from_mut<T>(s: &mut T) -> &mut [T; 1];

// core::slice
pub const fn from_ref<T>(s: &T) -> &[T];
pub const fn from_mut<T>(s: &mut T) -> &mut [T];
```

Note that `from_ref` methods require `const_raw_ptr_deref` feature (which seems totally fine, since it's being stabilized, see #89551), `from_mut` methods require `const_mut_refs` (which seems fine too since this PR marks `from_mut` functions as const unstable).

r? ````@oli-obk````
2021-10-24 15:48:44 +02:00
Pietro Albini
b63ab8005a update cfg(bootstrap) 2021-10-23 21:55:57 -04:00
Maybe Waffle
5f390cfb72 Add tests for const_slice_from_ref and const_array_from_ref 2021-10-23 22:51:22 +03:00
Maybe Waffle
27d6961134 Fill tracking issue for const_slice_from_ref and const_array_from_ref 2021-10-23 20:59:15 +03:00
Ilya Yanok
508fadab16 Update control_flow.rs
Fix and extent ControlFlow `traverse_inorder` example

1. The existing example compiles on its own, but any usage fails to be monomorphised and so doesn't compile. Fix that by using Fn trait instead of FnMut.
2. Added an example usage of `traverse_inorder` showing how we can terminate the traversal early.

Fixes #90063
2021-10-23 11:40:46 +02:00
Matthias Krüger
270c800d35
Rollup merge of #90117 - calebsander:fix/rsplit-clone, r=yaahc
Make RSplit<T, P>: Clone not require T: Clone

This addresses a TODO comment. The behavior of `#[derive(Clone)]` *does* result in a `T: Clone` requirement. Playground example:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=a8b1a9581ff8893baf401d624a53d35b

Add a manual `Clone` implementation, mirroring `Split` and `SplitInclusive`.
`(R)?SplitN(Mut)?` don't have any `Clone` implementations, but I'll leave that for its own pull request.
2021-10-23 05:28:26 +02:00
Matthias Krüger
5ea0274563
Rollup merge of #83233 - jethrogb:split_array, r=yaahc
Implement split_array and split_array_mut

This implements `[T]::split_array::<const N>() -> (&[T; N], &[T])` and `[T; N]::split_array::<const M>() -> (&[T; M], &[T])` and their mutable equivalents. These are another few “missing” array implementations now that const generics are a thing, similar to #74373, #75026, etc. Fixes #74674.

This implements `[T; N]::split_array` returning an array and a slice. Ultimately, this is probably not what we want, we would want the second return value to be an array of length N-M, which will likely be possible with future const generics enhancements. We need to implement the array method now though, to immediately shadow the slice method. This way, when the slice methods get stabilized, calling them on an array will not be automatic through coercion, so we won't have trouble stabilizing the array methods later (cf. into_iter debacle).

An unchecked version of `[T]::split_array` could also be added as in #76014. This would not be needed for `[T; N]::split_array` as that can be compile-time checked. Edit: actually, since split_at_unchecked is internal-only it could be changed to be split_array-only.
2021-10-23 05:28:19 +02:00
Noah Lev
865d99f82b docs: Escape brackets to satisfy the linkchecker
My change to use `Type::def_id()` (formerly `Type::def_id_full()`) in
more places caused some docs to show up that used to be missed by
rustdoc. Those docs contained unescaped square brackets, which triggered
linkcheck errors. This commit escapes the square brackets and adds this
particular instance to the linkcheck exception list.
2021-10-22 14:08:43 -07:00
Maybe Waffle
a288bf6afb Mark {array,slice}::{from_ref,from_mut} as const fn 2021-10-22 14:53:30 +03:00
Yuki Okushi
8b7adf63e1
Rollup merge of #89944 - mbartlett21:patch-2, r=Mark-Simulacrum
Change `Duration::[try_]from_secs_{f32, f64}` underflow error

The error message now says that it was a negative value.

Fixes #89913.
2021-10-22 19:42:47 +09:00
Yuki Okushi
918f9cc88b
Rollup merge of #88624 - kellerkindt:master, r=JohnTitor
Stabilize feature `saturating_div` for rust 1.58.0

The tracking issue is #89381

This seems like a reasonable simple change(?). The feature `saturating_div` was added as part of the ongoing effort to implement a `Saturating` integer type (see #87921). The implementation has been discussed [here](https://github.com/rust-lang/rust/pull/87921#issuecomment-899357720) and [here](https://github.com/rust-lang/rust/pull/87921#discussion_r691888556). It extends the list of saturating operations on integer types (like `saturating_add`, `saturating_sub`, `saturating_mul`, ...) by the function `fn saturating_div(self, rhs: Self) -> Self`.

The stabilization of the feature `saturating_int_impl` (for the `Saturating` type) needs to have this stabilized first.

Closes #89381
2021-10-22 19:42:42 +09:00
Jethro Beekman
4a439769ec Implement split_array and split_array_mut 2021-10-22 09:58:24 +02:00
Caleb Sander
afcee19d88 Make RSplit<T, P>: Clone not require T: Clone
This addresses a TODO comment. The behavior of #[derive(Clone)]
*does* result in a T: Clone requirement.

Add a manual Clone implementation, matching Split and SplitInclusive.
2021-10-21 21:25:59 -07:00
AlexApps99
361c978fbd
Added docs to internal_macro const 2021-10-22 10:07:35 +13:00
AlexApps99
23d033e177
Added const versions of common numeric operations
# Conflicts:
#	library/core/src/lib.rs
2021-10-22 10:03:18 +13:00
Michael Watzko
0dba9d0e42 Stabilize feature saturating_div for rust 1.58 2021-10-21 18:08:03 +02:00
mbartlett21
fe060bf247 Change Duration::from_secs_* underflow error
Now explicitly says negative value.
2021-10-20 08:48:00 +00:00
woppopo
2fc780638e Make From impls of NonZero integer const.
I also changed the feature gate added to `From` impls of Atomic integer to `const_num_from_num` from `const_convert`.
2021-10-20 12:04:58 +09:00
Miguel Ojeda
63d7882575 Stabilize option_result_unwrap_unchecked
Closes https://github.com/rust-lang/rust/issues/81383.

Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
2021-10-20 04:03:43 +02:00
Yuki Okushi
9f2ad0a061
Rollup merge of #90009 - woppopo:const_from_more, r=dtolnay
Make more `From` impls `const` (libcore)

Adding `const` to `From` implementations in the core. `rustc_const_unstable` attribute is not added to unstable implementations.

Tracking issue: #88674

<details>
<summary>Done</summary><div>

- `T` from `T`
- `T` from `!`
- `Option<T>` from `T`
- `Option<&T>` from `&Option<T>`
- `Option<&mut T>` from `&mut Option<T>`
- `Cell<T>` from `T`
- `RefCell<T>` from `T`
- `UnsafeCell<T>` from `T`
- `OnceCell<T>` from `T`
- `Poll<T>` from `T`
- `u32` from `char`
- `u64` from `char`
- `u128` from `char`
- `char` from `u8`
- `AtomicBool` from `bool`
- `AtomicPtr<T>` from `*mut T`
- `AtomicI(bits)` from `i(bits)`
- `AtomicU(bits)` from `u(bits)`
- `i(bits)` from `NonZeroI(bits)`
- `u(bits)` from `NonZeroU(bits)`
- `NonNull<T>` from `Unique<T>`
- `NonNull<T>` from `&T`
- `NonNull<T>` from `&mut T`
- `Unique<T>` from `&mut T`
- `Infallible` from `!`
- `TryIntError` from `!`
- `TryIntError` from `Infallible`
- `TryFromSliceError` from `Infallible`
- `FromResidual for Option<T>`
</div></details>

<details>
<summary>Remaining</summary><dev>

- `NonZero` from `NonZero`
These can't be made const at this time because these use Into::into.
https://github.com/rust-lang/rust/blob/master/library/core/src/convert/num.rs#L393

- `std`, `alloc`
There may still be many implementations that can be made `const`.
</div></details>
2021-10-20 04:35:15 +09:00
Yuki Okushi
f7024998c7
Rollup merge of #88860 - nbdd0121:panic, r=m-ou-se
Deduplicate panic_fmt

std's begin_panic_fmt and core's panic_fmt are duplicates. Merge them to declutter code and remove a lang item.
2021-10-20 04:35:14 +09:00
Yuki Okushi
84fe598f00
Rollup merge of #88789 - the8472:rm-zip-bound, r=JohnTitor
remove unnecessary bound on Zip specialization impl

I originally added this bound in an attempt to make the specialization
sound for owning iterators but it was never correct here and the correct
and [already implemented](497ee321af/library/alloc/src/vec/into_iter.rs (L220-L232)) solution is is to place it on the IntoIter
implementation.
2021-10-20 04:35:13 +09:00
Yuki Okushi
ca6798ab07
Rollup merge of #86479 - exphp-forks:float-debug-exponential, r=yaahc
Automatic exponential formatting in Debug

Context: See [this comment from the libs team](https://github.com/rust-lang/rfcs/pull/2729#issuecomment-853454204)

---

Makes `"{:?}"` switch to exponential for floats based on magnitude. The libs team suggested exploring this idea in the discussion thread for RFC rust-lang/rfcs#2729. (**note:** this is **not** an implementation of the RFC; it is an implementation of one of the alternatives)

Thresholds chosen were 1e-4 and 1e16.  Justification described [here](https://github.com/rust-lang/rfcs/pull/2729#issuecomment-864482954).

**This will require a crater run.**

---

As mentioned in the commit message of 8731d4dfb4, this behavior will not apply when a precision is supplied, because I wanted to preserve the following existing and useful behavior of `{:.PREC?}` (which recursively applies `{:.PREC}` to floats in a struct):

```rust
assert_eq!(
    format!("{:.2?}", [100.0, 0.000004]),
    "[100.00, 0.00]",
)
```

I looked around and am not sure where there are any tests that actually use this in the test suite, though?

All things considered, I'm surprised that this change did not seem to break even a single existing test in `x.py test --stage 2`.  (even when I tried a smaller threshold of 1e6)
2021-10-20 04:35:10 +09:00
Gary Guo
9370156957 Deduplicate panic_fmt
std's begin_panic_fmt and core's panic_fmt are duplicates.
Merge them to declutter code and remove a lang item.
2021-10-19 15:02:21 +01:00
bors
2f22e63cc4 Auto merge of #90037 - matthiaskrgr:rollup-cdfhxtn, r=matthiaskrgr
Rollup of 8 pull requests

Successful merges:

 - #89766 (RustWrapper: adapt for an LLVM API change)
 - #89867 (Fix macro_rules! duplication when reexported in the same module)
 - #89941 (removing TLS support in x86_64-unknown-none-hermitkernel)
 - #89956 (Suggest a case insensitive match name regardless of levenshtein distance)
 - #89988 (Do not promote values with const drop that need to be dropped)
 - #89997 (Add test for issue #84957 - `str.as_bytes()` in a `const` expression)
 - #90002 (⬆️ rust-analyzer)
 - #90034 (Tiny tweak to Iterator::unzip() doc comment example.)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
2021-10-19 05:04:38 +00:00
bors
cd8b56f528 Auto merge of #89905 - matthiaskrgr:rev_89709_entirely, r=michaelwoerister
Revert "Auto merge of #89709 - clemenswasser:apply_clippy_suggestions…

…_2, r=petrochenkov"

The PR had some unforseen perf regressions that are not as easy to find.
Revert the PR for now.

This reverts commit 6ae8912a3e, reversing
changes made to 86d6d2b738.
2021-10-19 02:03:21 +00:00
moxian
1519ca99d8 Tiny tweak to Iterator::unzip() doc comment example.
It's easier to figure out what it's doing and which output
elements map to which input ones if the matrix we are dealing
with is rectangular 2x3 rather than square 2x2.
2021-10-19 00:03:51 +00:00
woppopo
7936ecff48 Make more From impls const 2021-10-18 19:19:28 +09:00
Matthias Krüger
f044a84f5d
Rollup merge of #89977 - woppopo:result_const_as_mut, r=oli-obk
Make Result::as_mut const

Adding `const` for `Result::as_mut`.

Tracking issue: #82814
2021-10-17 18:19:00 +02:00
Matthias Krüger
1520fffecc
Rollup merge of #89945 - JohnTitor:we-now-specialize-clone-from-slice, r=the8472
Remove a mention to `copy_from_slice` from `clone_from_slice` doc

Fixes #84736
I think removing it would be the best but I'm happy to clarify it instead if someone would like.
2021-10-17 18:18:57 +02:00
woppopo
ea28abee28 Make Result::as_mut const 2021-10-17 18:39:54 +09:00
Yuki Okushi
0029af7930
Rollup merge of #89953 - woppopo:option_const_as_mut, r=oli-obk
Make Option::as_mut const

Adding `const` for `Option::as_mut`.

Tracking issue: #67441
2021-10-17 07:52:21 +09:00
Yuki Okushi
9614da27cd
Rollup merge of #89507 - lopopolo:lopopolo/ordering-repr-i8, r=joshtriplett
Add `#[repr(i8)]` to `Ordering`

Followup to #89491 to allow `Ordering` to auto-derive `AsRepr` once the proposal to add `AsRepr` (#81642) lands.

cc ``@joshtriplett``
2021-10-17 07:52:17 +09:00
woppopo
d1f7608699 Add #![cfg_attr(bootstrap, feature(const_panic))] to library/core/tests/lib.rs 2021-10-17 00:32:01 +09:00
woppopo
00dba3a693 Make Option::as_mut const 2021-10-17 00:02:42 +09:00
Yuki Okushi
1df185ac02
Remove a mention to copy_from_slice from clone_from_slice doc 2021-10-16 17:30:34 +09:00
Matthias Krüger
8e20470425
Rollup merge of #89925 - gilescope:update-docs-atomic-usage, r=m-ou-se
updating docs to mention usage of AtomicBool

Mouse mentioned we should point out that atomic bool is used by the std lib these days. ( https://github.com/m-ou-se/getrandom/pull/1 )
2021-10-16 08:02:28 +02:00
Matthias Krüger
9ae0804859
Rollup merge of #89509 - jhpratt:stabilize-const_unreachable_unchecked, r=oli-obk
Stabilize `unreachable_unchecked` as `const fn`

Closes #53188

This PR stabilizes `core::hint::unreachable_unchecked` as `const fn`. MIRI is able to detect when this method is called. Stabilization was delayed until `const_panic` was stabilized so as to avoid users calling this method in its place (thus resulting in runtime UB). With #89508, that is no longer an issue.

````@rustbot```` label +A-const-eval +A-const-fn +T-lang +S-blocked

(not sure why it's T-lang, but that's what the tracking issue is)
2021-10-16 08:02:20 +02:00
est31
7272b6fc8c Make char conversion functions unstably const 2021-10-16 01:20:02 +02:00
Giles Cope
d3bddf3ea1
updating docs to reflect current situation 2021-10-15 20:43:52 +01:00