Skip to content

Commit 69545c0

Browse files
ShaharNavehShaharNaveh
authored
Use Self where possible (RustPython#5892)
1 parent 05013e3 commit 69545c0

File tree

128 files changed

+738
-825
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

128 files changed

+738
-825
lines changed

‎common/src/atomic.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ impl<T> Default for OncePtr<T> {
6565
impl<T> OncePtr<T> {
6666
#[inline]
6767
pub fn new() -> Self {
68-
OncePtr {
68+
Self {
6969
inner: Radium::new(ptr::null_mut()),
7070
}
7171
}

‎common/src/boxvec.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -38,8 +38,8 @@ macro_rules! panic_oob {
3838
}
3939

4040
impl<T> BoxVec<T> {
41-
pub fn new(n: usize) -> BoxVec<T> {
42-
BoxVec {
41+
pub fn new(n: usize) -> Self {
42+
Self {
4343
xs: Box::new_uninit_slice(n),
4444
len: 0,
4545
}
@@ -593,7 +593,7 @@ where
593593
T: Clone,
594594
{
595595
fn clone(&self) -> Self {
596-
let mut new = BoxVec::new(self.capacity());
596+
let mut new = Self::new(self.capacity());
597597
new.extend(self.iter().cloned());
598598
new
599599
}
@@ -676,8 +676,8 @@ pub struct CapacityError<T = ()> {
676676

677677
impl<T> CapacityError<T> {
678678
/// Create a new `CapacityError` from `element`.
679-
pub const fn new(element: T) -> CapacityError<T> {
680-
CapacityError { element }
679+
pub const fn new(element: T) -> Self {
680+
Self { element }
681681
}
682682

683683
/// Extract the overflowing element

‎common/src/cformat.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -103,10 +103,10 @@ pub enum CFormatType {
103103
impl CFormatType {
104104
pub const fn to_char(self) -> char {
105105
match self {
106-
CFormatType::Number(x) => x as u8 as char,
107-
CFormatType::Float(x) => x as u8 as char,
108-
CFormatType::Character(x) => x as u8 as char,
109-
CFormatType::String(x) => x as u8 as char,
106+
Self::Number(x) => x as u8 as char,
107+
Self::Float(x) => x as u8 as char,
108+
Self::Character(x) => x as u8 as char,
109+
Self::String(x) => x as u8 as char,
110110
}
111111
}
112112
}
@@ -119,7 +119,7 @@ pub enum CFormatPrecision {
119119

120120
impl From<CFormatQuantity> for CFormatPrecision {
121121
fn from(quantity: CFormatQuantity) -> Self {
122-
CFormatPrecision::Quantity(quantity)
122+
Self::Quantity(quantity)
123123
}
124124
}
125125

@@ -338,7 +338,7 @@ impl CFormatSpec {
338338
_ => &num_chars,
339339
};
340340
let fill_chars_needed = width.saturating_sub(num_chars);
341-
let fill_string: T = CFormatSpec::compute_fill_string(fill_char, fill_chars_needed);
341+
let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
342342

343343
if !fill_string.is_empty() {
344344
if self.flags.contains(CConversionFlags::LEFT_ADJUST) {
@@ -361,7 +361,7 @@ impl CFormatSpec {
361361
_ => &num_chars,
362362
};
363363
let fill_chars_needed = width.saturating_sub(num_chars);
364-
let fill_string: T = CFormatSpec::compute_fill_string(fill_char, fill_chars_needed);
364+
let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
365365

366366
if !fill_string.is_empty() {
367367
// Don't left-adjust if precision-filling: that will always be prepending 0s to %d
@@ -721,13 +721,13 @@ pub enum CFormatPart<T> {
721721
impl<T> CFormatPart<T> {
722722
#[inline]
723723
pub const fn is_specifier(&self) -> bool {
724-
matches!(self, CFormatPart::Spec { .. })
724+
matches!(self, Self::Spec { .. })
725725
}
726726

727727
#[inline]
728728
pub const fn has_key(&self) -> bool {
729729
match self {
730-
CFormatPart::Spec(s) => s.mapping_key.is_some(),
730+
Self::Spec(s) => s.mapping_key.is_some(),
731731
_ => false,
732732
}
733733
}

‎common/src/format.rs‎

Lines changed: 35 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -38,23 +38,23 @@ impl FormatParse for FormatConversion {
3838
}
3939

4040
impl FormatConversion {
41-
pub fn from_char(c: CodePoint) -> Option<FormatConversion> {
41+
pub fn from_char(c: CodePoint) -> Option<Self> {
4242
match c.to_char_lossy() {
43-
's' => Some(FormatConversion::Str),
44-
'r' => Some(FormatConversion::Repr),
45-
'a' => Some(FormatConversion::Ascii),
46-
'b' => Some(FormatConversion::Bytes),
43+
's' => Some(Self::Str),
44+
'r' => Some(Self::Repr),
45+
'a' => Some(Self::Ascii),
46+
'b' => Some(Self::Bytes),
4747
_ => None,
4848
}
4949
}
5050

51-
fn from_string(text: &Wtf8) -> Option<FormatConversion> {
51+
fn from_string(text: &Wtf8) -> Option<Self> {
5252
let mut chars = text.code_points();
5353
if chars.next()? != '!' {
5454
return None;
5555
}
5656

57-
FormatConversion::from_char(chars.next()?)
57+
Self::from_char(chars.next()?)
5858
}
5959
}
6060

@@ -67,12 +67,12 @@ pub enum FormatAlign {
6767
}
6868

6969
impl FormatAlign {
70-
fn from_char(c: CodePoint) -> Option<FormatAlign> {
70+
fn from_char(c: CodePoint) -> Option<Self> {
7171
match c.to_char_lossy() {
72-
'<' => Some(FormatAlign::Left),
73-
'>' => Some(FormatAlign::Right),
74-
'=' => Some(FormatAlign::AfterSign),
75-
'^' => Some(FormatAlign::Center),
72+
'<' => Some(Self::Left),
73+
'>' => Some(Self::Right),
74+
'=' => Some(Self::AfterSign),
75+
'^' => Some(Self::Center),
7676
_ => None,
7777
}
7878
}
@@ -141,7 +141,7 @@ pub enum FormatType {
141141
}
142142

143143
impl From<&FormatType> for char {
144-
fn from(from: &FormatType) -> char {
144+
fn from(from: &FormatType) -> Self {
145145
match from {
146146
FormatType::String => 's',
147147
FormatType::Binary => 'b',
@@ -299,7 +299,7 @@ impl FormatSpec {
299299
align = align.or(Some(FormatAlign::AfterSign));
300300
}
301301

302-
Ok(FormatSpec {
302+
Ok(Self {
303303
conversion,
304304
fill,
305305
align,
@@ -327,7 +327,7 @@ impl FormatSpec {
327327
let magnitude_int_str = parts.next().unwrap().to_string();
328328
let dec_digit_cnt = magnitude_str.len() as i32 - magnitude_int_str.len() as i32;
329329
let int_digit_cnt = disp_digit_cnt - dec_digit_cnt;
330-
let mut result = FormatSpec::separate_integer(magnitude_int_str, inter, sep, int_digit_cnt);
330+
let mut result = Self::separate_integer(magnitude_int_str, inter, sep, int_digit_cnt);
331331
if let Some(part) = parts.next() {
332332
result.push_str(&format!(".{part}"))
333333
}
@@ -350,11 +350,11 @@ impl FormatSpec {
350350
// separate with 0 padding
351351
let padding = "0".repeat(diff as usize);
352352
let padded_num = format!("{padding}{magnitude_str}");
353-
FormatSpec::insert_separator(padded_num, inter, sep, sep_cnt)
353+
Self::insert_separator(padded_num, inter, sep, sep_cnt)
354354
} else {
355355
// separate without padding
356356
let sep_cnt = (magnitude_len - 1) / inter;
357-
FormatSpec::insert_separator(magnitude_str, inter, sep, sep_cnt)
357+
Self::insert_separator(magnitude_str, inter, sep, sep_cnt)
358358
}
359359
}
360360

@@ -412,12 +412,7 @@ impl FormatSpec {
412412
let magnitude_len = magnitude_str.len();
413413
let width = self.width.unwrap_or(magnitude_len) as i32 - prefix.len() as i32;
414414
let disp_digit_cnt = cmp::max(width, magnitude_len as i32);
415-
FormatSpec::add_magnitude_separators_for_char(
416-
magnitude_str,
417-
inter,
418-
sep,
419-
disp_digit_cnt,
420-
)
415+
Self::add_magnitude_separators_for_char(magnitude_str, inter, sep, disp_digit_cnt)
421416
}
422417
None => magnitude_str,
423418
}
@@ -640,27 +635,26 @@ impl FormatSpec {
640635
"{}{}{}",
641636
sign_str,
642637
magnitude_str,
643-
FormatSpec::compute_fill_string(fill_char, fill_chars_needed)
638+
Self::compute_fill_string(fill_char, fill_chars_needed)
644639
),
645640
FormatAlign::Right => format!(
646641
"{}{}{}",
647-
FormatSpec::compute_fill_string(fill_char, fill_chars_needed),
642+
Self::compute_fill_string(fill_char, fill_chars_needed),
648643
sign_str,
649644
magnitude_str
650645
),
651646
FormatAlign::AfterSign => format!(
652647
"{}{}{}",
653648
sign_str,
654-
FormatSpec::compute_fill_string(fill_char, fill_chars_needed),
649+
Self::compute_fill_string(fill_char, fill_chars_needed),
655650
magnitude_str
656651
),
657652
FormatAlign::Center => {
658653
let left_fill_chars_needed = fill_chars_needed / 2;
659654
let right_fill_chars_needed = fill_chars_needed - left_fill_chars_needed;
660-
let left_fill_string =
661-
FormatSpec::compute_fill_string(fill_char, left_fill_chars_needed);
655+
let left_fill_string = Self::compute_fill_string(fill_char, left_fill_chars_needed);
662656
let right_fill_string =
663-
FormatSpec::compute_fill_string(fill_char, right_fill_chars_needed);
657+
Self::compute_fill_string(fill_char, right_fill_chars_needed);
664658
format!("{left_fill_string}{sign_str}{magnitude_str}{right_fill_string}")
665659
}
666660
})
@@ -725,7 +719,7 @@ pub enum FormatParseError {
725719
impl FromStr for FormatSpec {
726720
type Err = FormatSpecError;
727721
fn from_str(s: &str) -> Result<Self, Self::Err> {
728-
FormatSpec::parse(s)
722+
Self::parse(s)
729723
}
730724
}
731725

@@ -739,7 +733,7 @@ pub enum FieldNamePart {
739733
impl FieldNamePart {
740734
fn parse_part(
741735
chars: &mut impl PeekingNext<Item = CodePoint>,
742-
) -> Result<Option<FieldNamePart>, FormatParseError> {
736+
) -> Result<Option<Self>, FormatParseError> {
743737
chars
744738
.next()
745739
.map(|ch| match ch.to_char_lossy() {
@@ -751,7 +745,7 @@ impl FieldNamePart {
751745
if attribute.is_empty() {
752746
Err(FormatParseError::EmptyAttribute)
753747
} else {
754-
Ok(FieldNamePart::Attribute(attribute))
748+
Ok(Self::Attribute(attribute))
755749
}
756750
}
757751
'[' => {
@@ -761,9 +755,9 @@ impl FieldNamePart {
761755
return if index.is_empty() {
762756
Err(FormatParseError::EmptyAttribute)
763757
} else if let Some(index) = parse_usize(&index) {
764-
Ok(FieldNamePart::Index(index))
758+
Ok(Self::Index(index))
765759
} else {
766-
Ok(FieldNamePart::StringIndex(index))
760+
Ok(Self::StringIndex(index))
767761
};
768762
}
769763
index.push(ch);
@@ -794,7 +788,7 @@ fn parse_usize(s: &Wtf8) -> Option<usize> {
794788
}
795789

796790
impl FieldName {
797-
pub fn parse(text: &Wtf8) -> Result<FieldName, FormatParseError> {
791+
pub fn parse(text: &Wtf8) -> Result<Self, FormatParseError> {
798792
let mut chars = text.code_points().peekable();
799793
let first: Wtf8Buf = chars
800794
.peeking_take_while(|ch| *ch != '.' && *ch != '[')
@@ -813,7 +807,7 @@ impl FieldName {
813807
parts.push(part)
814808
}
815809

816-
Ok(FieldName { field_type, parts })
810+
Ok(Self { field_type, parts })
817811
}
818812
}
819813

@@ -854,7 +848,7 @@ impl FormatString {
854848
let mut cur_text = text;
855849
let mut result_string = Wtf8Buf::new();
856850
while !cur_text.is_empty() {
857-
match FormatString::parse_literal_single(cur_text) {
851+
match Self::parse_literal_single(cur_text) {
858852
Ok((next_char, remaining)) => {
859853
result_string.push(next_char);
860854
cur_text = remaining;
@@ -968,7 +962,7 @@ impl FormatString {
968962
}
969963
if let Some(pos) = end_bracket_pos {
970964
let right = &text[pos..];
971-
let format_part = FormatString::parse_part_in_brackets(&left)?;
965+
let format_part = Self::parse_part_in_brackets(&left)?;
972966
Ok((format_part, &right[1..]))
973967
} else {
974968
Err(FormatParseError::UnmatchedBracket)
@@ -990,14 +984,14 @@ impl<'a> FromTemplate<'a> for FormatString {
990984
while !cur_text.is_empty() {
991985
// Try to parse both literals and bracketed format parts until we
992986
// run out of text
993-
cur_text = FormatString::parse_literal(cur_text)
994-
.or_else(|_| FormatString::parse_spec(cur_text))
987+
cur_text = Self::parse_literal(cur_text)
988+
.or_else(|_| Self::parse_spec(cur_text))
995989
.map(|(part, new_text)| {
996990
parts.push(part);
997991
new_text
998992
})?;
999993
}
1000-
Ok(FormatString {
994+
Ok(Self {
1001995
format_parts: parts,
1002996
})
1003997
}

‎common/src/linked_list.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -140,8 +140,8 @@ unsafe impl<T: Sync> Sync for Pointers<T> {}
140140

141141
impl<L, T> LinkedList<L, T> {
142142
/// Creates an empty linked list.
143-
pub const fn new() -> LinkedList<L, T> {
144-
LinkedList {
143+
pub const fn new() -> Self {
144+
Self {
145145
head: None,
146146
// tail: None,
147147
_marker: PhantomData,
@@ -323,8 +323,8 @@ where
323323

324324
impl<T> Pointers<T> {
325325
/// Create a new set of empty pointers
326-
pub fn new() -> Pointers<T> {
327-
Pointers {
326+
pub fn new() -> Self {
327+
Self {
328328
inner: UnsafeCell::new(PointersInner {
329329
prev: None,
330330
next: None,

‎common/src/lock/cell_lock.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ pub struct RawCellMutex {
1111

1212
unsafe impl RawMutex for RawCellMutex {
1313
#[allow(clippy::declare_interior_mutable_const)]
14-
const INIT: Self = RawCellMutex {
14+
const INIT: Self = Self {
1515
locked: Cell::new(false),
1616
};
1717

@@ -61,7 +61,7 @@ impl RawCellRwLock {
6161

6262
unsafe impl RawRwLock for RawCellRwLock {
6363
#[allow(clippy::declare_interior_mutable_const)]
64-
const INIT: Self = RawCellRwLock {
64+
const INIT: Self = Self {
6565
state: Cell::new(0),
6666
};
6767

@@ -203,7 +203,7 @@ fn deadlock(lock_kind: &str, ty: &str) -> ! {
203203

204204
pub struct SingleThreadId(());
205205
unsafe impl GetThreadId for SingleThreadId {
206-
const INIT: Self = SingleThreadId(());
206+
const INIT: Self = Self(());
207207
fn nonzero_thread_id(&self) -> NonZero<usize> {
208208
NonZero::new(1).unwrap()
209209
}

‎common/src/lock/thread_mutex.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ pub struct RawThreadMutex<R: RawMutex, G: GetThreadId> {
2121

2222
impl<R: RawMutex, G: GetThreadId> RawThreadMutex<R, G> {
2323
#[allow(clippy::declare_interior_mutable_const)]
24-
pub const INIT: Self = RawThreadMutex {
24+
pub const INIT: Self = Self {
2525
owner: AtomicUsize::new(0),
2626
mutex: R::INIT,
2727
get_thread_id: G::INIT,
@@ -79,7 +79,7 @@ pub struct ThreadMutex<R: RawMutex, G: GetThreadId, T: ?Sized> {
7979

8080
impl<R: RawMutex, G: GetThreadId, T> ThreadMutex<R, G, T> {
8181
pub fn new(val: T) -> Self {
82-
ThreadMutex {
82+
Self {
8383
raw: RawThreadMutex::INIT,
8484
data: UnsafeCell::new(val),
8585
}

0 commit comments

Comments
 (0)