Skip to content

Commit 77863c9

Browse files
rust-timerrust-timer
authored
Unrolled build for rust-lang#125362
Rollup merge of rust-lang#125362 - joboet:tait_hack, r=Nilstrieb Actually use TAIT instead of emulating it `core`'s `impl_fn_for_zst` macro is just a hacky way of emulating TAIT. TAIT has become stable enough to be used [in other places](https://github.com/rust-lang/rust/blob/e8fbd991287f637f95016a71ddc13438415bbe59/library/std/src/backtrace.rs#L431) inside the standard library, so let's use it in `core` as well.
2 parents 78dd504 + c398b2c commit 77863c9

File tree

5 files changed

+44
-117
lines changed

5 files changed

+44
-117
lines changed

‎library/core/src/internal_macros.rs

-41
Original file line numberDiff line numberDiff line change
@@ -80,47 +80,6 @@ macro_rules! forward_ref_op_assign {
8080
}
8181
}
8282

83-
/// Create a zero-size type similar to a closure type, but named.
84-
macro_rules! impl_fn_for_zst {
85-
($(
86-
$( #[$attr: meta] )*
87-
struct $Name: ident impl$( <$( $lifetime : lifetime ),+> )? Fn =
88-
|$( $arg: ident: $ArgTy: ty ),*| -> $ReturnTy: ty
89-
$body: block;
90-
)+) => {
91-
$(
92-
$( #[$attr] )*
93-
struct $Name;
94-
95-
impl $( <$( $lifetime ),+> )? Fn<($( $ArgTy, )*)> for $Name {
96-
#[inline]
97-
extern "rust-call" fn call(&self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
98-
$body
99-
}
100-
}
101-
102-
impl $( <$( $lifetime ),+> )? FnMut<($( $ArgTy, )*)> for $Name {
103-
#[inline]
104-
extern "rust-call" fn call_mut(
105-
&mut self,
106-
($( $arg, )*): ($( $ArgTy, )*)
107-
) -> $ReturnTy {
108-
Fn::call(&*self, ($( $arg, )*))
109-
}
110-
}
111-
112-
impl $( <$( $lifetime ),+> )? FnOnce<($( $ArgTy, )*)> for $Name {
113-
type Output = $ReturnTy;
114-
115-
#[inline]
116-
extern "rust-call" fn call_once(self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
117-
Fn::call(&self, ($( $arg, )*))
118-
}
119-
}
120-
)+
121-
}
122-
}
123-
12483
/// A macro for defining `#[cfg]` if-else statements.
12584
///
12685
/// `cfg_if` is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade

‎library/core/src/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -255,6 +255,7 @@
255255
#![feature(trait_alias)]
256256
#![feature(transparent_unions)]
257257
#![feature(try_blocks)]
258+
#![feature(type_alias_impl_trait)]
258259
#![feature(unboxed_closures)]
259260
#![feature(unsized_fn_params)]
260261
#![feature(with_negative_coherence)]

‎library/core/src/slice/ascii.rs

+2-7
Original file line numberDiff line numberDiff line change
@@ -108,7 +108,7 @@ impl [u8] {
108108
without modifying the original"]
109109
#[stable(feature = "inherent_ascii_escape", since = "1.60.0")]
110110
pub fn escape_ascii(&self) -> EscapeAscii<'_> {
111-
EscapeAscii { inner: self.iter().flat_map(EscapeByte) }
111+
EscapeAscii { inner: self.iter().flat_map(|byte| byte.escape_ascii()) }
112112
}
113113

114114
/// Returns a byte slice with leading ASCII whitespace bytes removed.
@@ -190,12 +190,7 @@ impl [u8] {
190190
}
191191
}
192192

193-
impl_fn_for_zst! {
194-
#[derive(Clone)]
195-
struct EscapeByte impl Fn = |byte: &u8| -> ascii::EscapeDefault {
196-
ascii::escape_default(*byte)
197-
};
198-
}
193+
type EscapeByte = impl (Fn(&u8) -> ascii::EscapeDefault) + Copy;
199194

200195
/// An iterator over the escaped version of a byte slice.
201196
///

‎library/core/src/str/iter.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -1274,8 +1274,10 @@ pub struct SplitWhitespace<'a> {
12741274
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
12751275
#[derive(Clone, Debug)]
12761276
pub struct SplitAsciiWhitespace<'a> {
1277-
pub(super) inner:
1278-
Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty>, UnsafeBytesToStr>,
1277+
pub(super) inner: Map<
1278+
Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty<'a>>,
1279+
UnsafeBytesToStr<'a>,
1280+
>,
12791281
}
12801282

12811283
/// An iterator over the substrings of a string,

‎library/core/src/str/mod.rs

+37-67
Original file line numberDiff line numberDiff line change
@@ -983,7 +983,7 @@ impl str {
983983
#[cfg_attr(not(test), rustc_diagnostic_item = "str_split_whitespace")]
984984
#[inline]
985985
pub fn split_whitespace(&self) -> SplitWhitespace<'_> {
986-
SplitWhitespace { inner: self.split(IsWhitespace).filter(IsNotEmpty) }
986+
SplitWhitespace { inner: self.split(char::is_whitespace).filter(|s| !s.is_empty()) }
987987
}
988988

989989
/// Splits a string slice by ASCII whitespace.
@@ -1032,8 +1032,13 @@ impl str {
10321032
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
10331033
#[inline]
10341034
pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> {
1035-
let inner =
1036-
self.as_bytes().split(IsAsciiWhitespace).filter(BytesIsNotEmpty).map(UnsafeBytesToStr);
1035+
let inner = self
1036+
.as_bytes()
1037+
.split(u8::is_ascii_whitespace)
1038+
.filter(|s| !s.is_empty())
1039+
// SAFETY: the byte slice came from a string and was only split
1040+
// along character boundaries, so the resulting slices are strings.
1041+
.map(|bytes| unsafe { from_utf8_unchecked(bytes) });
10371042
SplitAsciiWhitespace { inner }
10381043
}
10391044

@@ -1085,7 +1090,11 @@ impl str {
10851090
#[stable(feature = "rust1", since = "1.0.0")]
10861091
#[inline]
10871092
pub fn lines(&self) -> Lines<'_> {
1088-
Lines(self.split_inclusive('\n').map(LinesMap))
1093+
Lines(self.split_inclusive('\n').map(|line| {
1094+
let Some(line) = line.strip_suffix('\n') else { return line };
1095+
let Some(line) = line.strip_suffix('\r') else { return line };
1096+
line
1097+
}))
10891098
}
10901099

10911100
/// An iterator over the lines of a string.
@@ -2636,14 +2645,19 @@ impl str {
26362645
#[stable(feature = "str_escape", since = "1.34.0")]
26372646
pub fn escape_debug(&self) -> EscapeDebug<'_> {
26382647
let mut chars = self.chars();
2639-
EscapeDebug {
2640-
inner: chars
2641-
.next()
2642-
.map(|first| first.escape_debug_ext(EscapeDebugExtArgs::ESCAPE_ALL))
2643-
.into_iter()
2644-
.flatten()
2645-
.chain(chars.flat_map(CharEscapeDebugContinue)),
2646-
}
2648+
let first = chars
2649+
.next()
2650+
.map(|first| first.escape_debug_ext(EscapeDebugExtArgs::ESCAPE_ALL))
2651+
.into_iter()
2652+
.flatten();
2653+
let inner = first.chain(chars.flat_map(|c| {
2654+
c.escape_debug_ext(EscapeDebugExtArgs {
2655+
escape_grapheme_extended: false,
2656+
escape_single_quote: true,
2657+
escape_double_quote: true,
2658+
})
2659+
}));
2660+
EscapeDebug { inner }
26472661
}
26482662

26492663
/// Return an iterator that escapes each char in `self` with [`char::escape_default`].
@@ -2681,7 +2695,7 @@ impl str {
26812695
without modifying the original"]
26822696
#[stable(feature = "str_escape", since = "1.34.0")]
26832697
pub fn escape_default(&self) -> EscapeDefault<'_> {
2684-
EscapeDefault { inner: self.chars().flat_map(CharEscapeDefault) }
2698+
EscapeDefault { inner: self.chars().flat_map(char::escape_default) }
26852699
}
26862700

26872701
/// Return an iterator that escapes each char in `self` with [`char::escape_unicode`].
@@ -2719,7 +2733,7 @@ impl str {
27192733
without modifying the original"]
27202734
#[stable(feature = "str_escape", since = "1.34.0")]
27212735
pub fn escape_unicode(&self) -> EscapeUnicode<'_> {
2722-
EscapeUnicode { inner: self.chars().flat_map(CharEscapeUnicode) }
2736+
EscapeUnicode { inner: self.chars().flat_map(char::escape_unicode) }
27232737
}
27242738
}
27252739

@@ -2750,59 +2764,15 @@ impl Default for &mut str {
27502764
}
27512765
}
27522766

2753-
impl_fn_for_zst! {
2754-
/// A nameable, cloneable fn type
2755-
#[derive(Clone)]
2756-
struct LinesMap impl<'a> Fn = |line: &'a str| -> &'a str {
2757-
let Some(line) = line.strip_suffix('\n') else { return line };
2758-
let Some(line) = line.strip_suffix('\r') else { return line };
2759-
line
2760-
};
2761-
2762-
#[derive(Clone)]
2763-
struct CharEscapeDebugContinue impl Fn = |c: char| -> char::EscapeDebug {
2764-
c.escape_debug_ext(EscapeDebugExtArgs {
2765-
escape_grapheme_extended: false,
2766-
escape_single_quote: true,
2767-
escape_double_quote: true
2768-
})
2769-
};
2770-
2771-
#[derive(Clone)]
2772-
struct CharEscapeUnicode impl Fn = |c: char| -> char::EscapeUnicode {
2773-
c.escape_unicode()
2774-
};
2775-
#[derive(Clone)]
2776-
struct CharEscapeDefault impl Fn = |c: char| -> char::EscapeDefault {
2777-
c.escape_default()
2778-
};
2779-
2780-
#[derive(Clone)]
2781-
struct IsWhitespace impl Fn = |c: char| -> bool {
2782-
c.is_whitespace()
2783-
};
2784-
2785-
#[derive(Clone)]
2786-
struct IsAsciiWhitespace impl Fn = |byte: &u8| -> bool {
2787-
byte.is_ascii_whitespace()
2788-
};
2789-
2790-
#[derive(Clone)]
2791-
struct IsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b str| -> bool {
2792-
!s.is_empty()
2793-
};
2794-
2795-
#[derive(Clone)]
2796-
struct BytesIsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b [u8]| -> bool {
2797-
!s.is_empty()
2798-
};
2799-
2800-
#[derive(Clone)]
2801-
struct UnsafeBytesToStr impl<'a> Fn = |bytes: &'a [u8]| -> &'a str {
2802-
// SAFETY: not safe
2803-
unsafe { from_utf8_unchecked(bytes) }
2804-
};
2805-
}
2767+
type LinesMap = impl (Fn(&str) -> &str) + Copy;
2768+
type CharEscapeDebugContinue = impl (FnMut(char) -> char::EscapeDebug) + Copy;
2769+
type CharEscapeUnicode = impl (Fn(char) -> char::EscapeUnicode) + Copy;
2770+
type CharEscapeDefault = impl (Fn(char) -> char::EscapeDefault) + Copy;
2771+
type IsWhitespace = impl (Fn(char) -> bool) + Copy;
2772+
type IsAsciiWhitespace = impl (Fn(&u8) -> bool) + Copy;
2773+
type IsNotEmpty = impl (Fn(&&str) -> bool) + Copy;
2774+
type BytesIsNotEmpty<'a> = impl (FnMut(&&'a [u8]) -> bool) + Copy;
2775+
type UnsafeBytesToStr<'a> = impl (FnMut(&'a [u8]) -> &'a str) + Copy;
28062776

28072777
// This is required to make `impl From<&str> for Box<dyn Error>` and `impl<E> From<E> for Box<dyn Error>` not overlap.
28082778
#[stable(feature = "rust1", since = "1.0.0")]

0 commit comments

Comments
 (0)