8000 Cleanup uses (#926) · rune-rs/rune@ad53a83 · GitHub
[go: up one dir, main page]
Skip to content

Commit ad53a83

Browse files
udoprogudoprog
authored
Cleanup uses (#926)
1 parent a0a0f2b commit ad53a83

Some content is hidden

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

103 files changed

+463
-399
lines changed

‎crates/rune-alloc/src/alloc/global.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ use crate::alloc::{AllocError, Allocator};
44
use crate::ptr::{invalid_mut, NonNull};
55

66
#[cfg(feature = "alloc")]
7-
use ::rust_alloc::alloc::{alloc, alloc_zeroed, dealloc};
7+
use rust_alloc::alloc::{alloc, alloc_zeroed, dealloc};
88

99
/// Creates a `NonNull` that is dangling, but well-aligned for this Layout.
1010
///

‎crates/rune-alloc/src/borrow/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ use core::hash::{Hash, Hasher};
77
use core::ops::Deref;
88

99
#[cfg(feature = "alloc")]
10-
use ::rust_alloc::borrow::ToOwned;
10+
use rust_alloc::borrow::ToOwned;
1111

1212
use crate::clone::TryClone;
1313
use crate::error::Error;

‎crates/rune-alloc/src/boxed.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -251,15 +251,15 @@ impl<T: ?Sized> Box<T> {
251251
/// # Ok::<_, rune::alloc::Error>(())
252252
/// ```
253253
#[cfg(feature = "alloc")]
254-
pub fn from_std(b: ::rust_alloc::boxed::Box<T>) -> Result<Self, Error> {
254+
pub fn from_std(b: rust_alloc::boxed::Box<T>) -> Result<Self, Error> {
255255
// SAFETY: We've ensured that standard allocations only happen in an
256256
// allocator which is compatible with our `Global`.
257257
unsafe {
258258
// NB: Layout::for_value will return the size of the pointed to
259259
// value by the box, which for unsized types is the size of the
260260
// metadata. For sized types the value inside of the box.
261261
Global.take(Layout::for_value(b.as_ref()))?;
262-
let raw = ::rust_alloc::boxed::Box::into_raw(b);
262+
let raw = rust_alloc::boxed::Box::into_raw(b);
263263
Ok(Box::from_raw_in(raw, Global))
264264
}
265265
}
@@ -847,14 +847,14 @@ impl<A: Allocator> From<Box<str, A>> for Box<[u8], A> {
847847
}
848848

849849
#[cfg(feature = "alloc")]
850-
impl<T> TryFrom<::rust_alloc::boxed::Box<[T]>> for Box<[T]> {
850+
impl<T> TryFrom<rust_alloc::boxed::Box<[T]>> for Box<[T]> {
851851
type Error = Error;
852852

853853
#[inline]
854-
fn try_from(values: ::rust_alloc::boxed::Box<[T]>) -> Result<Self, Error> {
854+
fn try_from(values: rust_alloc::boxed::Box<[T]>) -> Result<Self, Error> {
855855
let mut vec = Vec::try_with_capacity(values.len())?;
856856

857-
for value in ::rust_alloc::vec::Vec::from(values) {
857+
for value in rust_alloc::vec::Vec::from(values) {
858858
vec.try_push(value)?;
859859
}
860860

@@ -988,7 +988,7 @@ impl TryFrom<&str> for Box<str> {
988988
}
989989

990990
#[cfg(feature = "alloc")]
991-
impl TryFrom<::rust_alloc::string::String> for Box<str> {
991+
impl TryFrom<rust_alloc::string::String> for Box<str> {
992992
type Error = Error;
993993

994994
/// Converts a std `String` into a `Box<str>`.
@@ -1004,7 +1004,7 @@ impl TryFrom<::rust_alloc::string::String> for Box<str> {
10041004
/// # Ok::<_, rune::alloc::Error>(())
10051005
/// ```
10061006
#[inline]
1007-
fn try_from(string: ::rust_alloc::string::String) -> Result<Self, Error> {
1007+
fn try_from(string: rust_alloc::string::String) -> Result<Self, Error> {
10081008
Box::from_std(string.into_boxed_str())
10091009
}
10101010
}

‎crates/rune-alloc/src/clone.rs

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -253,37 +253,37 @@ where
253253
}
254254

255255
#[cfg(feature = "alloc")]
256-
impl<T: ?Sized> TryClone for ::rust_alloc::sync::Arc<T> {
256+
impl<T: ?Sized> TryClone for rust_alloc::sync::Arc<T> {
257257
fn try_clone(&self) -> Result<Self, Error> {
258258
Ok(self.clone())
259259
}
260260
}
261261

262262
#[cfg(feature = "alloc")]
263-
impl<T: ?Sized> TryClone for ::rust_alloc::rc::Rc<T> {
263+
impl<T: ?Sized> TryClone for rust_alloc::rc::Rc<T> {
264264
fn try_clone(&self) -> Result<Self, Error> {
265265
Ok(self.clone())
266266
}
267267
}
268268

269269
#[cfg(feature = "alloc")]
270-
impl<T> TryClone for ::rust_alloc::boxed::Box<T>
270+
impl<T> TryClone for rust_alloc::boxed::Box<T>
271271
where
272272
T: TryClone,
273273
{
274274
fn try_clone(&self) -> Result<Self, Error> {
275-
Ok(::rust_alloc::boxed::Box::new(self.as_ref().try_clone()?))
275+
Ok(rust_alloc::boxed::Box::new(self.as_ref().try_clone()?))
276276
}
277277
}
278278

279279
#[cfg(feature = "alloc")]
280-
impl<T> TryClone for ::rust_alloc::boxed::Box<[T]>
280+
impl<T> TryClone for rust_alloc::boxed::Box<[T]>
281281
where
282282
T: TryClone,
283283
{
284284
fn try_clone(&self) -> Result<Self, Error> {
285285
// TODO: use a fallible box allocation.
286-
let mut out = ::rust_alloc::vec::Vec::with_capacity(self.len());
286+
let mut out = rust_alloc::vec::Vec::with_capacity(self.len());
287287

288288
for value in self.iter() {
289289
out.push(value.try_clone()?);
@@ -294,7 +294,7 @@ where
294294
}
295295

296296
#[cfg(feature = "alloc")]
297-
impl TryClone for ::rust_alloc::string::String {
297+
impl TryClone for rust_alloc::string::String {
298298
#[inline]
299299
fn try_clone(&self) -> Result<Self, Error> {
300300
// TODO: use fallible allocations for component.
@@ -303,13 +303,13 @@ impl TryClone for ::rust_alloc::string::String {
303303
}
304304

305305
#[cfg(all(test, feature = "alloc"))]
306-
impl<T> TryClone for ::rust_alloc::vec::Vec<T>
306+
impl<T> TryClone for rust_alloc::vec::Vec<T>
307307
where
308308
T: TryClone,
309309
{
310310
#[inline]
311311
fn try_clone(&self) -> Result<Self, Error> {
312-
let mut out = ::rust_alloc::vec::Vec::with_capacity(self.len());
312+
let mut out = rust_alloc::vec::Vec::with_capacity(self.len());
313313

314314
for value in self {
315315
out.push(value.try_clone()?);

‎crates/rune-alloc/src/hashbrown/map.rs

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -7078,8 +7078,8 @@ mod test_map {
70787078
use std::vec::Vec;
70797079
use std::{format, println};
70807080

7081-
use ::rust_alloc::string::{String, ToString};
7082-
use ::rust_alloc::sync::Arc;
7081+
use rust_alloc::string::{String, ToString};
7082+
use rust_alloc::sync::Arc;
70837083

70847084
use rand::{rngs::SmallRng, Rng, SeedableRng};
70857085

@@ -7212,7 +7212,7 @@ mod test_map {
72127212
#[test]
72137213
fn test_drops() {
72147214
DROP_VECTOR.with(|slot| {
7215-
*slot.borrow_mut() = ::rust_alloc::vec![0; 200];
7215+
*slot.borrow_mut() = rust_alloc::vec![0; 200];
72167216
});
72177217

72187218
{
@@ -7271,7 +7271,7 @@ mod test_map {
72717271
#[test]
72727272
fn test_into_iter_drops() {
72737273
DROP_VECTOR.with(|v| {
7274-
*v.borrow_mut() = ::rust_alloc::vec![0; 200];
7274+
*v.borrow_mut() = rust_alloc::vec![0; 200];
72757275
});
72767276

72777277
let hm = {
@@ -7542,7 +7542,7 @@ mod test_map {
75427542

75437543
#[test]
75447544
fn test_keys() {
7545-
let vec = ::rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
7545+
let vec = rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
75467546
let map: HashMap<_, _> = vec.into_iter().collect();
75477547
let keys: Vec<_> = map.keys().copied().collect();
75487548
assert_eq!(keys.len(), 3);
@@ -7553,7 +7553,7 @@ mod test_map {
75537553

75547554
#[test]
75557555
fn test_values() {
7556-
let vec = ::rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
7556+
let vec = rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
75577557
let map: HashMap<_, _> = vec.into_iter().collect();
75587558
let values: Vec<_> = map.values().copied().collect();
75597559
assert_eq!(values.len(), 3);
@@ -7564,7 +7564,7 @@ mod test_map {
75647564

75657565
#[test]
75667566
fn test_values_mut() {
7567-
let vec = ::rust_alloc::vec![(1, 1), (2, 2), (3, 3)];
7567+
let vec = rust_alloc::vec![(1, 1), (2, 2), (3, 3)];
75687568
let mut map: HashMap<_, _> = vec.into_iter().collect();
75697569
for value in map.values_mut() {
75707570
*value *= 2;
@@ -7578,7 +7578,7 @@ mod test_map {
75787578

75797579
#[test]
75807580
fn test_into_keys() {
7581-
let vec = ::rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
7581+
let vec = rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
75827582
let map: HashMap<_, _> = vec.into_iter().collect();
75837583
let keys: Vec<_> = map. 741A into_keys().collect();
75847584

@@ -7590,7 +7590,7 @@ mod test_map {
75907590

75917591
#[test]
75927592
fn test_into_values() {
7593-
let vec = ::rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
7593+
let vec = rust_alloc::vec![(1, 'a'), (2, 'b'), (3, 'c')];
75947594
let map: HashMap<_, _> = vec.into_iter().collect();
75957595
let values: Vec<_> = map.into_values().collect();
75967596

@@ -8537,7 +8537,7 @@ mod test_map {
85378537
let drained = map.extract_if(|&k, _| k % 2 == 0);
85388538
let mut out = drained.collect::<Vec<_>>();
85398539
out.sort_unstable();
8540-
assert_eq!(::rust_alloc::vec![(0, 0), (2, 20), (4, 40), (6, 60)], out);
8540+
assert_eq!(rust_alloc::vec![(0, 0), (2, 20), (4, 40), (6, 60)], out);
85418541
assert_eq!(map.len(), 4);
85428542
}
85438543
{
@@ -8904,7 +8904,7 @@ mod test_map {
89048904
#[test]
89058905
#[should_panic = "panic in clone"]
89068906
fn test_clone_from_memory_leaks() {
8907-
use ::rust_alloc::vec::Vec;
8907+
use rust_alloc::vec::Vec;
89088908

89098909
struct CheckedClone {
89108910
panic_in_clone: bool,
@@ -8926,23 +8926,23 @@ mod test_map {
89268926
1,
89278927
CheckedClone {
89288928
panic_in_clone: false,
8929-
need_drop: ::rust_alloc::vec![0, 1, 2],
8929+
need_drop: rust_alloc::vec![0, 1, 2],
89308930
},
89318931
)
89328932
.unwrap();
89338933
map1.try_insert(
89348934
2,
89358935
CheckedClone {
89368936
panic_in_clone: false,
8937-
need_drop: ::rust_alloc::vec![3, 4, 5],
8937+
need_drop: rust_alloc::vec![3, 4, 5],
89388938
},
89398939
)
89408940
.unwrap();
89418941
map1.try_insert(
89428942
3,
89438943
CheckedClone {
89448944
panic_in_clone: true,
8945-
need_drop: ::rust_alloc::vec![6, 7, 8],
8945+
need_drop: rust_alloc::vec![6, 7, 8],
89468946
},
89478947
)
89488948
.unwrap();
@@ -9165,7 +9165,7 @@ mod test_map {
91659165
let map: HashMap<u64, CheckedCloneDrop<Vec<u64>>, DefaultHashBuilder, MyAlloc> =
91669166
match get_test_map(
91679167
ARMED_FLAGS.into_iter().zip(DISARMED_FLAGS),
9168-
|n| ::rust_alloc::vec![n],
9168+
|n| rust_alloc::vec![n],
91699169
MyAlloc::new(dropped.clone()),
91709170
) {
91719171
Ok(map) => map,
@@ -9224,7 +9224,7 @@ mod test_map {
92249224

92259225
let mut map = match get_test_map(
92269226
DISARMED_FLAGS.into_iter().zip(DISARMED_FLAGS),
9227-
|n| ::rust_alloc::vec![n],
9227+
|n| rust_alloc::vec![n],
92289228
MyAlloc::new(dropped.clone()),
92299229
) {
92309230
Ok(map) => map,
@@ -9234,7 +9234,7 @@ mod test_map {
92349234
thread::scope(|s| {
92359235
let result: thread::ScopedJoinHandle<'_, String> = s.spawn(|| {
92369236
let scope_map =
9237-
match get_test_map(ARMED_FLAGS.into_iter().zip(DISARMED_FLAGS), |n| ::rust_alloc::vec![n * 2], MyAlloc::new(dropped.clone())) {
9237+
match get_test_map(ARMED_FLAGS.into_iter().zip(DISARMED_FLAGS), |n| rust_alloc::vec![n * 2], MyAlloc::new(dropped.clone())) {
92389238
Ok(map) => map,
92399239
Err(msg) => return msg,
92409240
};
@@ -9291,7 +9291,7 @@ mod test_map {
92919291

92929292
let mut map = match get_test_map(
92939293
[DISARMED].into_iter().zip([DISARMED]),
9294-
|n| ::rust_alloc::vec![n],
9294+
|n| rust_alloc::vec![n],
92959295
MyAlloc::new(dropped.clone()),
92969296
) {
92979297
Ok(map) => map,
@@ -9302,7 +9302,7 @@ mod test_map {
93029302
let result: thread::ScopedJoinHandle<'_, String> = s.spawn(|| {
93039303
let scope_map = match get_test_map(
93049304
ARMED_FLAGS.into_iter().zip(DISARMED_FLAGS),
9305-
|n| ::rust_alloc::vec![n * 2],
9305+
|n| rust_alloc::vec![n * 2],
93069306
MyAlloc::new(dropped.clone()),
93079307
) {
93089308
Ok(map) => map,

‎crates/rune-alloc/src/hashbrown/raw/mod.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4064,7 +4064,7 @@ mod test_map {
40644064
/// AN UNINITIALIZED TABLE DURING THE DROP
40654065
#[test]
40664066
fn test_drop_uninitialized() {
4067-
use ::rust_alloc::vec::Vec;
4067+
use rust_alloc::vec::Vec;
40684068

40694069
let table = unsafe {
40704070
// SAFETY: The `buckets` is power of two and we're not
@@ -4078,7 +4078,7 @@ mod test_map {
40784078
/// ARE ZERO, EVEN IF WE HAVE `FULL` CONTROL BYTES.
40794079
#[test]
40804080
fn test_drop_zero_items() {
4081-
use ::rust_alloc::vec::Vec;
4081+
use rust_alloc::vec::Vec;
40824082
unsafe {
40834083
// SAFETY: The `buckets` is power of two and we're not
40844084
// trying to actually use the returned RawTable.
@@ -4125,9 +4125,9 @@ mod test_map {
41254125
#[test]
41264126
fn test_catch_panic_clone_from() {
41274127
use crate::alloc::{AllocError, Allocator};
4128-
use ::rust_alloc::sync::Arc;
4129-
use ::rust_alloc::vec::Vec;
41304128
use core::sync::atomic::{AtomicI8, Ordering};
4129+
use rust_alloc::sync::Arc;
4130+
use rust_alloc::vec::Vec;
41314131
use std::thread;
41324132

41334133
struct MyAllocInner {
@@ -4208,7 +4208,7 @@ mod test_map {
42084208
CheckedCloneDrop {
42094209
panic_in_clone,
42104210
dropped: false,
4211-
need_drop: ::rust_alloc::vec![idx],
4211+
need_drop: rust_alloc::vec![idx],
42124212
},
42134213
),
42144214
|_: &mut (), (k, _): &(u64, _)| Ok::<_, Infallible>(*k),
@@ -4239,7 +4239,7 @@ mod test_map {
42394239
CheckedCloneDrop {
42404240
panic_in_clone,
42414241
dropped: false,
4242-
need_drop: ::rust_alloc::vec![idx + 100],
4242+
need_drop: rust_alloc::vec![idx + 100],
42434243
},
42444244
),
42454245
|_: &mut (), (k, _): &(u64, _)| Ok::<_, Infallible>(*k),

0 commit comments

Comments
 (0)
0