language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-28 04:44:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

internal: switch some tests to minicore

Browse source
This commit is contained in:
Aleksey Kladov 2021-06-15 21:11:53 +03:00
parent f521e41853
commit f841369fee
2 changed files with 88 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

197
crates/hir_ty/src/tests/coercion.rs
View file

@ -122,60 +122,52 @@ fn infer_let_stmt_coerce() {
fn infer_custom_coerce_unsized() { fn infer_custom_coerce_unsized() {
check_infer( check_infer(
r#" r#"
struct A<T: ?Sized>(*const T); //- minicore: coerce_unsized
struct B<T: ?Sized>(*const T); use core::{marker::Unsize, ops::CoerceUnsized};
struct C<T: ?Sized> { inner: *const T }
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {} struct A<T: ?Sized>(*const T);
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {} struct B<T: ?Sized>(*const T);
struct C<T: ?Sized> { inner: *const T }
fn foo1<T>(x: A<[T]>) -> A<[T]> { x } impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
fn foo2<T>(x: B<[T]>) -> B<[T]> { x } impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) { fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
let d = foo1(a); fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
let e = foo2(b); fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
let f = foo3(c);
}
fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
#[lang = "sized"] let d = foo1(a);
pub trait Sized {} let e = foo2(b);
#[lang = "unsize"] let f = foo3(c);
pub trait Unsize<T: ?Sized> {} }
#[lang = "coerce_unsized"] "#,
pub trait CoerceUnsized<T> {}
impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
"#,
expect![[r#" expect![[r#"
257..258 'x': A<[T]> 306..307 'x': A<[T]>
278..283 '{ x }': A<[T]> 327..332 '{ x }': A<[T]>
280..281 'x': A<[T]> 329..330 'x': A<[T]>
295..296 'x': B<[T]> 344..345 'x': B<[T]>
316..321 '{ x }': B<[T]> 365..370 '{ x }': B<[T]>
318..319 'x': B<[T]> 367..368 'x': B<[T]>
333..334 'x': C<[T]> 382..383 'x': C<[T]>
354..359 '{ x }': C<[T]> 403..408 '{ x }': C<[T]>
356..357 'x': C<[T]> 405..406 'x': C<[T]>
369..370 'a': A<[u8; 2]> 418..419 'a': A<[u8; 2]>
384..385 'b': B<[u8; 2]> 433..434 'b': B<[u8; 2]>
399..400 'c': C<[u8; 2]> 448..449 'c': C<[u8; 2]>
414..480 '{ ...(c); }': () 463..529 '{ ...(c); }': ()
424..425 'd': A<[{unknown}]> 473..474 'd': A<[{unknown}]>
428..432 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]> 477..481 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
428..435 'foo1(a)': A<[{unknown}]> 477..484 'foo1(a)': A<[{unknown}]>
433..434 'a': A<[u8; 2]> 482..483 'a': A<[u8; 2]>
445..446 'e': B<[u8]> 494..495 'e': B<[u8]>
449..453 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]> 498..502 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
449..456 'foo2(b)': B<[u8]> 498..505 'foo2(b)': B<[u8]>
454..455 'b': B<[u8; 2]> 503..504 'b': B<[u8; 2]>
466..467 'f': C<[u8]> 515..516 'f': C<[u8]>
470..474 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]> 519..523 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
470..477 'foo3(c)': C<[u8]> 519..526 'foo3(c)': C<[u8]>
475..476 'c': C<[u8; 2]> 524..525 'c': C<[u8; 2]>
"#]], "#]],
); );
} }
@ -184,21 +176,16 @@ fn infer_custom_coerce_unsized() {
fn infer_if_coerce() { fn infer_if_coerce() {
check_infer( check_infer(
r#" r#"
fn foo<T>(x: &[T]) -> &[T] { loop {} } //- minicore: unsize
fn test() { fn foo<T>(x: &[T]) -> &[T] { loop {} }
let x = if true { fn test() {
foo(&[1]) let x = if true {
} else { foo(&[1])
&[1] } else {
}; &[1]
} };
}
"#,
#[lang = "sized"]
pub trait Sized {}
#[lang = "unsize"]
pub trait Unsize<T: ?Sized> {}
"#,
expect![[r#" expect![[r#"
10..11 'x': &[T] 10..11 'x': &[T]
27..38 '{ loop {} }': &[T] 27..38 '{ loop {} }': &[T]
@ -226,25 +213,16 @@ fn infer_if_coerce() {
fn infer_if_else_coerce() { fn infer_if_else_coerce() {
check_infer( check_infer(
r#" r#"
fn foo<T>(x: &[T]) -> &[T] { loop {} } //- minicore: coerce_unsized
fn test() { fn foo<T>(x: &[T]) -> &[T] { loop {} }
let x = if true { fn test() {
&[1] let x = if true {
} else { &[1]
foo(&[1]) } else {
}; foo(&[1])
} };
}
#[lang = "sized"] "#,
pub trait Sized {}
#[lang = "unsize"]
pub trait Unsize<T: ?Sized> {}
#[lang = "coerce_unsized"]
pub trait CoerceUnsized<T> {}
impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
"#,
expect![[r#" expect![[r#"
10..11 'x': &[T] 10..11 'x': &[T]
27..38 '{ loop {} }': &[T] 27..38 '{ loop {} }': &[T]
@ -272,20 +250,16 @@ fn infer_if_else_coerce() {
fn infer_match_first_coerce() { fn infer_match_first_coerce() {
check_infer( check_infer(
r#" r#"
fn foo<T>(x: &[T]) -> &[T] { loop {} } //- minicore: unsize
fn test(i: i32) { fn foo<T>(x: &[T]) -> &[T] { loop {} }
let x = match i { fn test(i: i32) {
2 => foo(&[2]), let x = match i {
1 => &[1], 2 => foo(&[2]),
_ => &[3], 1 => &[1],
}; _ => &[3],
} };
}
#[lang = "sized"] "#,
pub trait Sized {}
#[lang = "unsize"]
pub trait Unsize<T: ?Sized> {}
"#,
expect![[r#" expect![[r#"
10..11 'x': &[T] 10..11 'x': &[T]
27..38 '{ loop {} }': &[T] 27..38 '{ loop {} }': &[T]
@ -320,25 +294,16 @@ fn infer_match_first_coerce() {
fn infer_match_second_coerce() { fn infer_match_second_coerce() {
check_infer( check_infer(
r#" r#"
fn foo<T>(x: &[T]) -> &[T] { loop {} } //- minicore: coerce_unsized
fn test(i: i32) { fn foo<T>(x: &[T]) -> &[T] { loop {} }
let x = match i { fn test(i: i32) {
1 => &[1], let x = match i {
2 => foo(&[2]), 1 => &[1],
_ => &[3], 2 => foo(&[2]),
}; _ => &[3],
} };
}
#[lang = "sized"] "#,
pub trait Sized {}
#[lang = "unsize"]
pub trait Unsize<T: ?Sized> {}
#[lang = "coerce_unsized"]
pub trait CoerceUnsized<T> {}
impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
"#,
expect![[r#" expect![[r#"
10..11 'x': &[T] 10..11 'x': &[T]
27..38 '{ loop {} }': &[T] 27..38 '{ loop {} }': &[T]

9
crates/test_utils/src/minicore.rs
View file

@ -9,7 +9,8 @@
//! //!
//! Available flags: //! Available flags:
//! sized: //! sized:
//! coerce_unsized: sized //! unsize: sized
//! coerce_unsized: unsize
pub mod marker { pub mod marker {
// region:sized // region:sized
@ -17,10 +18,12 @@ pub mod marker {
#[fundamental] #[fundamental]
#[rustc_specialization_trait] #[rustc_specialization_trait]
pub trait Sized {} pub trait Sized {}
// endregion:sized
// region:unsize
#[lang = "unsize"] #[lang = "unsize"]
pub trait Unsize<T: ?Sized> {} pub trait Unsize<T: ?Sized> {}
// endregion:sized // endregion:unsize
} }
pub mod ops { pub mod ops {
@ -44,6 +47,8 @@ pub mod ops {
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {} impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
// endregion:coerce_unsized // endregion:coerce_unsized
} }
pub use self::unsize::CoerceUnsized; // :coerce_unsized
} }
pub mod prelude { pub mod prelude {