bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #109684 - fee1-dead-contrib:rv_const_range, r=Mark-Simulacrum

Browse source 
Revert #104100, Allow using `Range` as an `Iterator` in const contexts.

This fixes #109632.
This commit is contained in:
bors 2023-04-09 15:42:27 +00:00
commit 1c39afb375
14 changed files with 65 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

32
library/core/src/iter/range.rs
View file

@ -1,5 +1,4 @@
use crate::convert::TryFrom;
use crate::marker::Destruct;
use crate::mem;
use crate::num::NonZeroUsize;
use crate::ops::{self, Try};
@ -22,8 +21,7 @@ unsafe_impl_trusted_step![char i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usi
/// The *successor* operation moves towards values that compare greater.
/// The *predecessor* operation moves towards values that compare lesser.
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[const_trait]
pub trait Step: ~const Clone + ~const PartialOrd + Sized {
pub trait Step: Clone + PartialOrd + Sized {
/// Returns the number of *successor* steps required to get from `start` to `end`.
///
/// Returns `None` if the number of steps would overflow `usize`
@ -237,8 +235,7 @@ macro_rules! step_integer_impls {
$(
#[allow(unreachable_patterns)]
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl const Step for $u_narrower {
impl Step for $u_narrower {
step_identical_methods!();
#[inline]
@ -270,8 +267,7 @@ macro_rules! step_integer_impls {
#[allow(unreachable_patterns)]
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl const Step for $i_narrower {
impl Step for $i_narrower {
step_identical_methods!();
#[inline]
@ -335,8 +331,7 @@ macro_rules! step_integer_impls {
$(
#[allow(unreachable_patterns)]
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl const Step for $u_wider {
impl Step for $u_wider {
step_identical_methods!();
#[inline]
@ -361,8 +356,7 @@ macro_rules! step_integer_impls {
#[allow(unreachable_patterns)]
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl const Step for $i_wider {
impl Step for $i_wider {
step_identical_methods!();
#[inline]
@ -412,8 +406,7 @@ step_integer_impls! {
}
#[unstable(feature = "step_trait", reason = "recently redesigned", issue = "42168")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl const Step for char {
impl Step for char {
#[inline]
fn steps_between(&start: &char, &end: &char) -> Option<usize> {
let start = start as u32;
@ -431,7 +424,6 @@ impl const Step for char {
}
#[inline]
#[rustc_allow_const_fn_unstable(const_try)]
fn forward_checked(start: char, count: usize) -> Option<char> {
let start = start as u32;
let mut res = Step::forward_checked(start, count)?;
@ -448,7 +440,6 @@ impl const Step for char {
}
#[inline]
#[rustc_allow_const_fn_unstable(const_try)]
fn backward_checked(start: char, count: usize) -> Option<char> {
let start = start as u32;
let mut res = Step::backward_checked(start, count)?;
@ -524,7 +515,6 @@ macro_rules! range_incl_exact_iter_impl {
}
/// Specialization implementations for `Range`.
#[const_trait]
trait RangeIteratorImpl {
type Item;
@ -539,7 +529,7 @@ trait RangeIteratorImpl {
fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>;
}
impl<A: ~const Step + ~const Destruct> const RangeIteratorImpl for ops::Range<A> {
impl<A: Step> RangeIteratorImpl for ops::Range<A> {
type Item = A;
#[inline]
@ -625,7 +615,7 @@ impl<A: ~const Step + ~const Destruct> const RangeIteratorImpl for ops::Range<A>
}
}
impl<T: ~const TrustedStep + ~const Destruct> const RangeIteratorImpl for ops::Range<T> {
impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
#[inline]
fn spec_next(&mut self) -> Option<T> {
if self.start < self.end {
@ -713,8 +703,7 @@ impl<T: ~const TrustedStep + ~const Destruct> const RangeIteratorImpl for ops::R
}
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl<A: ~const Step + ~const Destruct> const Iterator for ops::Range<A> {
impl<A: Step> Iterator for ops::Range<A> {
type Item = A;
#[inline]
@ -824,8 +813,7 @@ range_incl_exact_iter_impl! {
}
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
impl<A: ~const Step + ~const Destruct> const DoubleEndedIterator for ops::Range<A> {
impl<A: Step> DoubleEndedIterator for ops::Range<A> {
#[inline]
fn next_back(&mut self) -> Option<A> {
self.spec_next_back()

11
library/core/src/iter/traits/double_ended.rs
View file

@ -1,4 +1,3 @@
use crate::marker::Destruct;
use crate::num::NonZeroUsize;
use crate::ops::{ControlFlow, Try};
@ -39,7 +38,6 @@ use crate::ops::{ControlFlow, Try};
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "DoubleEndedIterator")]
#[const_trait]
pub trait DoubleEndedIterator: Iterator {
/// Removes and returns an element from the end of the iterator.
///
@ -136,10 +134,7 @@ pub trait DoubleEndedIterator: Iterator {
/// [`Err(k)`]: Err
#[inline]
#[unstable(feature = "iter_advance_by", reason = "recently added", issue = "77404")]
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
where
Self::Item: ~const Destruct,
{
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize> {
for i in 0..n {
if self.next_back().is_none() {
// SAFETY: `i` is always less than `n`.
@ -192,7 +187,6 @@ pub trait DoubleEndedIterator: Iterator {
/// ```
#[inline]
#[stable(feature = "iter_nth_back", since = "1.37.0")]
#[rustc_do_not_const_check]
fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
if self.advance_back_by(n).is_err() {
return None;
@ -232,7 +226,6 @@ pub trait DoubleEndedIterator: Iterator {
/// ```
#[inline]
#[stable(feature = "iterator_try_fold", since = "1.27.0")]
#[rustc_do_not_const_check]
fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
where
Self: Sized,
@ -304,7 +297,6 @@ pub trait DoubleEndedIterator: Iterator {
#[doc(alias = "foldr")]
#[inline]
#[stable(feature = "iter_rfold", since = "1.27.0")]
#[rustc_do_not_const_check]
fn rfold<B, F>(mut self, init: B, mut f: F) -> B
where
Self: Sized,
@ -360,7 +352,6 @@ pub trait DoubleEndedIterator: Iterator {
/// ```
#[inline]
#[stable(feature = "iter_rfind", since = "1.27.0")]
#[rustc_do_not_const_check]
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where
Self: Sized,

13
library/core/src/iter/traits/iterator.rs
View file

@ -1,6 +1,5 @@
use crate::array;
use crate::cmp::{self, Ordering};
use crate::marker::Destruct;
use crate::num::NonZeroUsize;
use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, Residual, Try};
@ -340,10 +339,8 @@ pub trait Iterator {
/// ```
#[inline]
#[unstable(feature = "iter_advance_by", reason = "recently added", issue = "77404")]
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
where
Self::Item: ~const Destruct,
{
#[rustc_do_not_const_check]
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> {
for i in 0..n {
if self.next().is_none() {
// SAFETY: `i` is always less than `n`.
@ -394,10 +391,8 @@ pub trait Iterator {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn nth(&mut self, n: usize) -> Option<Self::Item>
where
Self::Item: ~const Destruct,
{
#[rustc_do_not_const_check]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.advance_by(n).ok()?;
self.next()
}

3
library/core/src/iter/traits/marker.rs
View file

@ -86,5 +86,4 @@ pub unsafe trait InPlaceIterable: Iterator {}
/// for details. Consumers are free to rely on the invariants in unsafe code.
#[unstable(feature = "trusted_step", issue = "85731")]
#[rustc_specialization_trait]
#[const_trait]
pub unsafe trait TrustedStep: ~const Step {}
pub unsafe trait TrustedStep: Step {}

2
library/core/src/lib.rs
View file

@ -123,11 +123,9 @@
#![feature(const_index_range_slice_index)]
#![feature(const_inherent_unchecked_arith)]
#![feature(const_int_unchecked_arith)]
#![feature(const_intoiterator_identity)]
#![feature(const_intrinsic_forget)]
#![feature(const_ipv4)]
#![feature(const_ipv6)]
#![feature(const_iter)]
#![feature(const_likely)]
#![feature(const_maybe_uninit_uninit_array)]
#![feature(const_maybe_uninit_as_mut_ptr)]

36
library/core/tests/iter/consts.rs
View file

@ -1,36 +0,0 @@
#[test]
fn const_manual_iter() {
struct S(bool);
impl const Iterator for S {
type Item = ();
fn next(&mut self) -> Option<Self::Item> {
if self.0 == false {
self.0 = true;
Some(())
} else {
None
}
}
}
const {
let mut val = S(false);
assert!(val.next().is_some());
assert!(val.next().is_none());
assert!(val.next().is_none());
}
}
#[test]
fn const_range() {
const {
let mut arr = [0; 3];
for i in 0..arr.len() {
arr[i] = i;
}
assert!(arr[0] == 0);
assert!(arr[1] == 1);
assert!(arr[2] == 2);
}
}

2
library/core/tests/iter/mod.rs
View file

@ -20,8 +20,6 @@ mod range;
mod sources;
mod traits;
mod consts;
use core::cell::Cell;
use core::convert::TryFrom;
use core::iter::*;

3
library/core/tests/lib.rs
View file

@ -12,11 +12,8 @@
#![feature(const_caller_location)]
#![feature(const_cell_into_inner)]
#![feature(const_convert)]
#![feature(const_for)]
#![feature(const_hash)]
#![feature(const_heap)]
#![feature(const_intoiterator_identity)]
#![feature(const_iter)]
#![feature(const_maybe_uninit_as_mut_ptr)]
#![feature(const_maybe_uninit_assume_init_read)]
#![feature(const_nonnull_new)]