Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #17134 - Veykril:lt-err-display, r=Veykril

Browse source 
internal: Don't render unknown lifetimes when rendering generic args

cc https://github.com/rust-lang/rust-analyzer/issues/17098
This commit is contained in:
bors 2024-04-25 07:36:47 +00:00
commit 935de9d773
15 changed files with 631 additions and 586 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
crates/hir-ty/src/display.rs
View file

@ -797,8 +797,20 @@ impl HirDisplay for Ty {
c.hir_fmt(f)?; c.hir_fmt(f)?;
write!(f, "]")?; write!(f, "]")?;
} }
TyKind::Raw(m, t) | TyKind::Ref(m, _, t) => { kind @ (TyKind::Raw(m, t) | TyKind::Ref(m, _, t)) => {
if matches!(self.kind(Interner), TyKind::Raw(..)) { if let TyKind::Ref(_, l, _) = kind {
f.write_char('&')?;
if cfg!(test) {
// rendering these unconditionally is probably too much (at least for inlay
// hints) so we gate it to testing only for the time being
l.hir_fmt(f)?;
f.write_char(' ')?;
}
match m {
Mutability::Not => (),
Mutability::Mut => f.write_str("mut ")?,
}
} else {
write!( write!(
f, f,
"*{}", "*{}",
@ -807,15 +819,6 @@ impl HirDisplay for Ty {
Mutability::Mut => "mut ", Mutability::Mut => "mut ",
} }
)?; )?;
} else {
write!(
f,
"&{}",
match m {
Mutability::Not => "",
Mutability::Mut => "mut ",
}
)?;
} }
// FIXME: all this just to decide whether to use parentheses... // FIXME: all this just to decide whether to use parentheses...
@ -1330,7 +1333,18 @@ fn hir_fmt_generics(
} }
let parameters_to_write = generic_args_sans_defaults(f, generic_def, parameters); let parameters_to_write = generic_args_sans_defaults(f, generic_def, parameters);
if !parameters_to_write.is_empty() {
// FIXME: Remote this
// most of our lifetimes will be errors as we lack elision and inference
// so don't render them for now
let only_err_lifetimes = !cfg!(test)
&& parameters_to_write.iter().all(|arg| {
matches!(
arg.data(Interner),
chalk_ir::GenericArgData::Lifetime(it) if *it.data(Interner) == LifetimeData::Error
)
});
if !parameters_to_write.is_empty() && !only_err_lifetimes {
write!(f, "<")?; write!(f, "<")?;
hir_fmt_generic_arguments(f, parameters_to_write)?; hir_fmt_generic_arguments(f, parameters_to_write)?;
write!(f, ">")?; write!(f, ">")?;
@ -1403,6 +1417,18 @@ fn hir_fmt_generic_arguments(
None => (parameters, &[][..]), None => (parameters, &[][..]),
}; };
for generic_arg in lifetimes.iter().chain(ty_or_const) { for generic_arg in lifetimes.iter().chain(ty_or_const) {
// FIXME: Remove this
// most of our lifetimes will be errors as we lack elision and inference
// so don't render them for now
if !cfg!(test)
&& matches!(
generic_arg.lifetime(Interner),
Some(l) if ***l.interned() == LifetimeData::Error
)
{
continue;
}
if !first { if !first {
write!(f, ", ")?; write!(f, ", ")?;
} }
@ -1728,9 +1754,9 @@ impl HirDisplay for LifetimeData {
LifetimeData::BoundVar(idx) => idx.hir_fmt(f), LifetimeData::BoundVar(idx) => idx.hir_fmt(f),
LifetimeData::InferenceVar(_) => write!(f, "_"), LifetimeData::InferenceVar(_) => write!(f, "_"),
LifetimeData::Static => write!(f, "'static"), LifetimeData::Static => write!(f, "'static"),
LifetimeData::Error => write!(f, "'{{error}}"), LifetimeData::Error => write!(f, "'?"),
LifetimeData::Erased => Ok(()), LifetimeData::Erased => write!(f, "'<erased>"),
LifetimeData::Phantom(_, _) => Ok(()), LifetimeData::Phantom(void, _) => match *void {},
} }
} }
} }

14
crates/hir-ty/src/tests/coercion.rs
View file

@ -186,7 +186,7 @@ fn test() {
let x = match 1 { let x = match 1 {
1 => t as *mut i32, 1 => t as *mut i32,
2 => t as &i32, 2 => t as &i32,
//^^^^^^^^^ expected *mut i32, got &i32 //^^^^^^^^^ expected *mut i32, got &'? i32
_ => t as *const i32, _ => t as *const i32,
// ^^^^^^^^^^^^^^^ adjustments: Pointer(MutToConstPointer) // ^^^^^^^^^^^^^^^ adjustments: Pointer(MutToConstPointer)
@ -307,7 +307,7 @@ fn test() {
let foo = Foo; let foo = Foo;
//^^^ type: Foo<{unknown}> //^^^ type: Foo<{unknown}>
let _: &u32 = &Foo; let _: &u32 = &Foo;
//^^^^ expected &u32, got &Foo<{unknown}> //^^^^ expected &'? u32, got &'? Foo<{unknown}>
}", }",
); );
} }
@ -544,9 +544,9 @@ struct Bar<T>(Foo<T>);
fn test() { fn test() {
let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] }; let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
//^^^^^^^^^^^^^^^^^^^^^ expected &Foo<[usize]>, got &Foo<[i32; 3]> //^^^^^^^^^^^^^^^^^^^^^ expected &'? Foo<[usize]>, got &'? Foo<[i32; 3]>
let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] }); let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
//^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &Bar<[usize]>, got &Bar<[i32; 3]> //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &'? Bar<[usize]>, got &'? Bar<[i32; 3]>
} }
"#, "#,
); );
@ -562,7 +562,7 @@ trait Foo {}
fn test(f: impl Foo, g: &(impl Foo + ?Sized)) { fn test(f: impl Foo, g: &(impl Foo + ?Sized)) {
let _: &dyn Foo = &f; let _: &dyn Foo = &f;
let _: &dyn Foo = g; let _: &dyn Foo = g;
//^ expected &dyn Foo, got &impl Foo + ?Sized //^ expected &'? dyn Foo, got &'? impl Foo + ?Sized
} }
"#, "#,
); );
@ -828,11 +828,11 @@ struct V<T> { t: T }
fn main() { fn main() {
let a: V<&dyn Tr>; let a: V<&dyn Tr>;
(a,) = V { t: &S }; (a,) = V { t: &S };
//^^^^expected V<&S>, got (V<&dyn Tr>,) //^^^^expected V<&'? S>, got (V<&'? dyn Tr>,)
let mut a: V<&dyn Tr> = V { t: &S }; let mut a: V<&dyn Tr> = V { t: &S };
(a,) = V { t: &S }; (a,) = V { t: &S };
//^^^^expected V<&S>, got (V<&dyn Tr>,) //^^^^expected V<&'? S>, got (V<&'? dyn Tr>,)
} }
"#, "#,
); );

14
crates/hir-ty/src/tests/diagnostics.rs
View file

@ -8,7 +8,7 @@ fn function_return_type_mismatch_1() {
r#" r#"
fn test() -> &'static str { fn test() -> &'static str {
5 5
//^ expected &str, got i32 //^ expected &'static str, got i32
} }
"#, "#,
); );
@ -21,7 +21,7 @@ fn function_return_type_mismatch_2() {
fn test(x: bool) -> &'static str { fn test(x: bool) -> &'static str {
if x { if x {
return 1; return 1;
//^ expected &str, got i32 //^ expected &'static str, got i32
} }
"ok" "ok"
} }
@ -38,7 +38,7 @@ fn test(x: bool) -> &'static str {
return "ok"; return "ok";
} }
1 1
//^ expected &str, got i32 //^ expected &'static str, got i32
} }
"#, "#,
); );
@ -53,7 +53,7 @@ fn test(x: bool) -> &'static str {
"ok" "ok"
} else { } else {
1 1
//^ expected &str, got i32 //^ expected &'static str, got i32
} }
} }
"#, "#,
@ -67,7 +67,7 @@ fn function_return_type_mismatch_5() {
fn test(x: bool) -> &'static str { fn test(x: bool) -> &'static str {
if x { if x {
1 1
//^ expected &str, got i32 //^ expected &'static str, got i32
} else { } else {
"ok" "ok"
} }
@ -83,10 +83,10 @@ fn non_unit_block_expr_stmt_no_semi() {
fn test(x: bool) { fn test(x: bool) {
if x { if x {
"notok" "notok"
//^^^^^^^ expected (), got &str //^^^^^^^ expected (), got &'static str
} else { } else {
"ok" "ok"
//^^^^ expected (), got &str //^^^^ expected (), got &'static str
} }
match x { true => true, false => 0 } match x { true => true, false => 0 }
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), got bool //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), got bool

14
crates/hir-ty/src/tests/display_source_code.rs
View file

@ -67,11 +67,11 @@ trait B: A {}
fn test( fn test(
_: &(dyn A<Assoc = ()> + Send), _: &(dyn A<Assoc = ()> + Send),
//^ &(dyn A<Assoc = ()> + Send) //^ &'_ (dyn A<Assoc = ()> + Send)
_: &(dyn Send + A<Assoc = ()>), _: &(dyn Send + A<Assoc = ()>),
//^ &(dyn A<Assoc = ()> + Send) //^ &'_ (dyn A<Assoc = ()> + Send)
_: &dyn B<Assoc = ()>, _: &dyn B<Assoc = ()>,
//^ &(dyn B<Assoc = ()>) //^ &'_ (dyn B<Assoc = ()>)
) {} ) {}
"#, "#,
); );
@ -85,7 +85,7 @@ fn render_dyn_for_ty() {
trait Foo<'a> {} trait Foo<'a> {}
fn foo(foo: &dyn for<'a> Foo<'a>) {} fn foo(foo: &dyn for<'a> Foo<'a>) {}
// ^^^ &dyn Foo<'_> // ^^^ &'_ dyn Foo<'_>
"#, "#,
); );
} }
@ -111,11 +111,11 @@ fn test(
b; b;
//^ impl Foo //^ impl Foo
c; c;
//^ &impl Foo + ?Sized //^ &'_ impl Foo + ?Sized
d; d;
//^ S<impl Foo> //^ S<impl Foo>
ref_any; ref_any;
//^^^^^^^ &impl ?Sized //^^^^^^^ &'_ impl ?Sized
empty; empty;
} //^^^^^ impl Sized } //^^^^^ impl Sized
"#, "#,
@ -192,7 +192,7 @@ fn test(
b; b;
//^ fn(impl Foo) -> impl Foo //^ fn(impl Foo) -> impl Foo
c; c;
} //^ fn(&impl Foo + ?Sized) -> &impl Foo + ?Sized } //^ fn(&'_ impl Foo + ?Sized) -> &'_ impl Foo + ?Sized
"#, "#,
); );
} }

34
crates/hir-ty/src/tests/macros.rs
View file

@ -200,8 +200,8 @@ fn expr_macro_def_expanded_in_various_places() {
100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize> 100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize>
100..119 'for _ ...!() {}': ! 100..119 'for _ ...!() {}': !
100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize> 100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize>
100..119 'for _ ...!() {}': &mut IntoIterator::IntoIter<isize> 100..119 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>
100..119 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item> 100..119 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>
100..119 'for _ ...!() {}': Option<IntoIterator::Item<isize>> 100..119 'for _ ...!() {}': Option<IntoIterator::Item<isize>>
100..119 'for _ ...!() {}': () 100..119 'for _ ...!() {}': ()
100..119 'for _ ...!() {}': () 100..119 'for _ ...!() {}': ()
@ -221,7 +221,7 @@ fn expr_macro_def_expanded_in_various_places() {
281..303 'Spam {...m!() }': {unknown} 281..303 'Spam {...m!() }': {unknown}
309..325 'spam!(...am!()]': {unknown} 309..325 'spam!(...am!()]': {unknown}
350..366 'spam!(... usize': usize 350..366 'spam!(... usize': usize
372..380 '&spam!()': &isize 372..380 '&spam!()': &'? isize
386..394 '-spam!()': isize 386..394 '-spam!()': isize
400..416 'spam!(...pam!()': {unknown} 400..416 'spam!(...pam!()': {unknown}
422..439 'spam!(...pam!()': isize 422..439 'spam!(...pam!()': isize
@ -293,8 +293,8 @@ fn expr_macro_rules_expanded_in_various_places() {
114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize> 114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize>
114..133 'for _ ...!() {}': ! 114..133 'for _ ...!() {}': !
114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize> 114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize>
114..133 'for _ ...!() {}': &mut IntoIterator::IntoIter<isize> 114..133 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>
114..133 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item> 114..133 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>
114..133 'for _ ...!() {}': Option<IntoIterator::Item<isize>> 114..133 'for _ ...!() {}': Option<IntoIterator::Item<isize>>
114..133 'for _ ...!() {}': () 114..133 'for _ ...!() {}': ()
114..133 'for _ ...!() {}': () 114..133 'for _ ...!() {}': ()
@ -314,7 +314,7 @@ fn expr_macro_rules_expanded_in_various_places() {
295..317 'Spam {...m!() }': {unknown} 295..317 'Spam {...m!() }': {unknown}
323..339 'spam!(...am!()]': {unknown} 323..339 'spam!(...am!()]': {unknown}
364..380 'spam!(... usize': usize 364..380 'spam!(... usize': usize
386..394 '&spam!()': &isize 386..394 '&spam!()': &'? isize
400..408 '-spam!()': isize 400..408 '-spam!()': isize
414..430 'spam!(...pam!()': {unknown} 414..430 'spam!(...pam!()': {unknown}
436..453 'spam!(...pam!()': isize 436..453 'spam!(...pam!()': isize
@ -539,7 +539,7 @@ fn test() {
let msg = foo::Message(foo::MessageRef); let msg = foo::Message(foo::MessageRef);
let r = msg.deref(); let r = msg.deref();
r; r;
//^ &MessageRef //^ &'? MessageRef
} }
//- /lib.rs crate:foo //- /lib.rs crate:foo
@ -703,9 +703,9 @@ fn infer_builtin_macros_file() {
} }
"#, "#,
expect![[r#" expect![[r#"
!0..2 '""': &str !0..2 '""': &'static str
63..87 '{ ...!(); }': () 63..87 '{ ...!(); }': ()
73..74 'x': &str 73..74 'x': &'static str
"#]], "#]],
); );
} }
@ -741,9 +741,9 @@ fn infer_builtin_macros_concat() {
} }
"#, "#,
expect![[r#" expect![[r#"
!0..13 '"helloworld!"': &str !0..13 '"helloworld!"': &'static str
65..121 '{ ...")); }': () 65..121 '{ ...")); }': ()
75..76 'x': &str 75..76 'x': &'static str
"#]], "#]],
); );
} }
@ -820,7 +820,7 @@ macro_rules! include_str {() => {}}
fn main() { fn main() {
let a = include_str!("foo.rs"); let a = include_str!("foo.rs");
a; a;
} //^ &str } //^ &'static str
//- /foo.rs //- /foo.rs
hello hello
@ -847,7 +847,7 @@ macro_rules! m {
fn main() { fn main() {
let a = include_str!(m!(".rs")); let a = include_str!(m!(".rs"));
a; a;
} //^ &str } //^ &'static str
//- /foo.rs //- /foo.rs
hello hello
@ -960,9 +960,9 @@ fn infer_builtin_macros_concat_with_lazy() {
} }
"#, "#,
expect![[r#" expect![[r#"
!0..13 '"helloworld!"': &str !0..13 '"helloworld!"': &'static str
103..160 '{ ...")); }': () 103..160 '{ ...")); }': ()
113..114 'x': &str 113..114 'x': &'static str
"#]], "#]],
); );
} }
@ -977,7 +977,7 @@ fn infer_builtin_macros_env() {
fn main() { fn main() {
let x = env!("foo"); let x = env!("foo");
//^ &str //^ &'static str
} }
"#, "#,
); );
@ -991,7 +991,7 @@ fn infer_builtin_macros_option_env() {
//- /main.rs env:foo=bar //- /main.rs env:foo=bar
fn main() { fn main() {
let x = option_env!("foo"); let x = option_env!("foo");
//^ Option<&str> //^ Option<&'static str>
} }
"#, "#,
); );

32
crates/hir-ty/src/tests/method_resolution.rs
View file

@ -658,7 +658,7 @@ fn infer_call_trait_method_on_generic_param_1() {
} }
"#, "#,
expect![[r#" expect![[r#"
29..33 'self': &Self 29..33 'self': &'? Self
63..64 't': T 63..64 't': T
69..88 '{ ...d(); }': () 69..88 '{ ...d(); }': ()
75..76 't': T 75..76 't': T
@ -679,7 +679,7 @@ fn infer_call_trait_method_on_generic_param_2() {
} }
"#, "#,
expect![[r#" expect![[r#"
32..36 'self': &Self 32..36 'self': &'? Self
70..71 't': T 70..71 't': T
76..95 '{ ...d(); }': () 76..95 '{ ...d(); }': ()
82..83 't': T 82..83 't': T
@ -757,7 +757,7 @@ struct S;
impl Clone for S {} impl Clone for S {}
impl Clone for &S {} impl Clone for &S {}
fn test() { (S.clone(), (&S).clone(), (&&S).clone()); } fn test() { (S.clone(), (&S).clone(), (&&S).clone()); }
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (S, S, &S) //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (S, S, &'? S)
"#, "#,
); );
} }
@ -1150,12 +1150,12 @@ fn dyn_trait_super_trait_not_in_scope() {
} }
"#, "#,
expect![[r#" expect![[r#"
51..55 'self': &Self 51..55 'self': &'? Self
64..69 '{ 0 }': u32 64..69 '{ 0 }': u32
66..67 '0': u32 66..67 '0': u32
176..177 'd': &dyn Trait 176..177 'd': &'? dyn Trait
191..207 '{ ...o(); }': () 191..207 '{ ...o(); }': ()
197..198 'd': &dyn Trait 197..198 'd': &'? dyn Trait
197..204 'd.foo()': u32 197..204 'd.foo()': u32
"#]], "#]],
); );
@ -1182,15 +1182,15 @@ fn test() {
} }
"#, "#,
expect![[r#" expect![[r#"
75..79 'self': &S 75..79 'self': &'? S
89..109 '{ ... }': bool 89..109 '{ ... }': bool
99..103 'true': bool 99..103 'true': bool
123..167 '{ ...o(); }': () 123..167 '{ ...o(); }': ()
133..134 's': &S 133..134 's': &'? S
137..151 'unsafe { f() }': &S 137..151 'unsafe { f() }': &'static S
146..147 'f': fn f() -> &S 146..147 'f': fn f() -> &'static S
146..149 'f()': &S 146..149 'f()': &'static S
157..158 's': &S 157..158 's': &'? S
157..164 's.foo()': bool 157..164 's.foo()': bool
"#]], "#]],
); );
@ -1601,11 +1601,11 @@ use core::IntoIterator;
fn f() { fn f() {
let v = [4].into_iter(); let v = [4].into_iter();
v; v;
//^ &i32 //^ &'? i32
let a = [0, 1].into_iter(); let a = [0, 1].into_iter();
a; a;
//^ &i32 //^ &'? i32
} }
//- /main2021.rs crate:main2021 deps:core edition:2021 //- /main2021.rs crate:main2021 deps:core edition:2021
@ -1618,7 +1618,7 @@ fn f() {
let a = [0, 1].into_iter(); let a = [0, 1].into_iter();
a; a;
//^ &i32 //^ &'? i32
} }
//- /core.rs crate:core //- /core.rs crate:core
@ -1767,7 +1767,7 @@ fn test() {
let a2 = A(make(), 1i32); let a2 = A(make(), 1i32);
let _: &str = a2.thing(); let _: &str = a2.thing();
a2; a2;
//^^ A<C<&str>, i32> //^^ A<C<&'? str>, i32>
} }
"#, "#,
); );

18
crates/hir-ty/src/tests/never_type.rs
View file

@ -104,7 +104,7 @@ enum Option<T> { None, Some(T) }
fn test() { fn test() {
let a = if true { Option::None } else { Option::Some(return) }; let a = if true { Option::None } else { Option::Some(return) };
a; a;
//^ Option<&str> //^ Option<&'static str>
match 42 { match 42 {
42 => a, 42 => a,
_ => Option::Some("str"), _ => Option::Some("str"),
@ -317,8 +317,8 @@ fn diverging_expression_2() {
63..81 '{ loop...foo" }': u32 63..81 '{ loop...foo" }': u32
65..72 'loop {}': ! 65..72 'loop {}': !
70..72 '{}': () 70..72 '{}': ()
74..79 '"foo"': &str 74..79 '"foo"': &'static str
74..79: expected u32, got &str 74..79: expected u32, got &'static str
"#]], "#]],
); );
} }
@ -365,8 +365,8 @@ fn diverging_expression_3_break() {
151..172 'for a ...eak; }': {unknown} 151..172 'for a ...eak; }': {unknown}
151..172 'for a ...eak; }': ! 151..172 'for a ...eak; }': !
151..172 'for a ...eak; }': {unknown} 151..172 'for a ...eak; }': {unknown}
151..172 'for a ...eak; }': &mut {unknown} 151..172 'for a ...eak; }': &'? mut {unknown}
151..172 'for a ...eak; }': fn next<{unknown}>(&mut {unknown}) -> Option<<{unknown} as Iterator>::Item> 151..172 'for a ...eak; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
151..172 'for a ...eak; }': Option<{unknown}> 151..172 'for a ...eak; }': Option<{unknown}>
151..172 'for a ...eak; }': () 151..172 'for a ...eak; }': ()
151..172 'for a ...eak; }': () 151..172 'for a ...eak; }': ()
@ -381,8 +381,8 @@ fn diverging_expression_3_break() {
237..250 'for a in b {}': {unknown} 237..250 'for a in b {}': {unknown}
237..250 'for a in b {}': ! 237..250 'for a in b {}': !
237..250 'for a in b {}': {unknown} 237..250 'for a in b {}': {unknown}
237..250 'for a in b {}': &mut {unknown} 237..250 'for a in b {}': &'? mut {unknown}
237..250 'for a in b {}': fn next<{unknown}>(&mut {unknown}) -> Option<<{unknown} as Iterator>::Item> 237..250 'for a in b {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
237..250 'for a in b {}': Option<{unknown}> 237..250 'for a in b {}': Option<{unknown}>
237..250 'for a in b {}': () 237..250 'for a in b {}': ()
237..250 'for a in b {}': () 237..250 'for a in b {}': ()
@ -396,8 +396,8 @@ fn diverging_expression_3_break() {
315..337 'for a ...urn; }': {unknown} 315..337 'for a ...urn; }': {unknown}
315..337 'for a ...urn; }': ! 315..337 'for a ...urn; }': !
315..337 'for a ...urn; }': {unknown} 315..337 'for a ...urn; }': {unknown}
315..337 'for a ...urn; }': &mut {unknown} 315..337 'for a ...urn; }': &'? mut {unknown}
315..337 'for a ...urn; }': fn next<{unknown}>(&mut {unknown}) -> Option<<{unknown} as Iterator>::Item> 315..337 'for a ...urn; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
315..337 'for a ...urn; }': Option<{unknown}> 315..337 'for a ...urn; }': Option<{unknown}>
315..337 'for a ...urn; }': () 315..337 'for a ...urn; }': ()
315..337 'for a ...urn; }': () 315..337 'for a ...urn; }': ()

208
crates/hir-ty/src/tests/patterns.rs
View file

@ -32,27 +32,27 @@ fn infer_pattern() {
} }
"#, "#,
expect![[r#" expect![[r#"
8..9 'x': &i32 8..9 'x': &'? i32
17..400 '{ ...o_x; }': () 17..400 '{ ...o_x; }': ()
27..28 'y': &i32 27..28 'y': &'? i32
31..32 'x': &i32 31..32 'x': &'? i32
42..44 '&z': &i32 42..44 '&z': &'? i32
43..44 'z': i32 43..44 'z': i32
47..48 'x': &i32 47..48 'x': &'? i32
58..59 'a': i32 58..59 'a': i32
62..63 'z': i32 62..63 'z': i32
73..79 '(c, d)': (i32, &str) 73..79 '(c, d)': (i32, &'static str)
74..75 'c': i32 74..75 'c': i32
77..78 'd': &str 77..78 'd': &'static str
82..94 '(1, "hello")': (i32, &str) 82..94 '(1, "hello")': (i32, &'static str)
83..84 '1': i32 83..84 '1': i32
86..93 '"hello"': &str 86..93 '"hello"': &'static str
101..151 'for (e... }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter 101..151 'for (e... }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
101..151 'for (e... }': {unknown} 101..151 'for (e... }': {unknown}
101..151 'for (e... }': ! 101..151 'for (e... }': !
101..151 'for (e... }': {unknown} 101..151 'for (e... }': {unknown}
101..151 'for (e... }': &mut {unknown} 101..151 'for (e... }': &'? mut {unknown}
101..151 'for (e... }': fn next<{unknown}>(&mut {unknown}) -> Option<<{unknown} as Iterator>::Item> 101..151 'for (e... }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
101..151 'for (e... }': Option<({unknown}, {unknown})> 101..151 'for (e... }': Option<({unknown}, {unknown})>
101..151 'for (e... }': () 101..151 'for (e... }': ()
101..151 'for (e... }': () 101..151 'for (e... }': ()
@ -74,10 +74,10 @@ fn infer_pattern() {
194..197 'val': {unknown} 194..197 'val': {unknown}
210..236 'if let...rue {}': () 210..236 'if let...rue {}': ()
213..233 'let x ... &true': bool 213..233 'let x ... &true': bool
217..225 'x @ true': &bool 217..225 'x @ true': &'? bool
221..225 'true': bool 221..225 'true': bool
221..225 'true': bool 221..225 'true': bool
228..233 '&true': &bool 228..233 '&true': &'? bool
229..233 'true': bool 229..233 'true': bool
234..236 '{}': () 234..236 '{}': ()
246..252 'lambda': impl Fn(u64, u64, i32) -> i32 246..252 'lambda': impl Fn(u64, u64, i32) -> i32
@ -90,14 +90,14 @@ fn infer_pattern() {
277..282 'a + b': u64 277..282 'a + b': u64
281..282 'b': u64 281..282 'b': u64
284..285 'c': i32 284..285 'c': i32
298..310 'ref ref_to_x': &&i32 298..310 'ref ref_to_x': &'? &'? i32
313..314 'x': &i32 313..314 'x': &'? i32
324..333 'mut mut_x': &i32 324..333 'mut mut_x': &'? i32
336..337 'x': &i32 336..337 'x': &'? i32
347..367 'ref mu...f_to_x': &mut &i32 347..367 'ref mu...f_to_x': &'? mut &'? i32
370..371 'x': &i32 370..371 'x': &'? i32
381..382 'k': &mut &i32 381..382 'k': &'? mut &'? i32
385..397 'mut_ref_to_x': &mut &i32 385..397 'mut_ref_to_x': &'? mut &'? i32
"#]], "#]],
); );
} }
@ -120,14 +120,14 @@ fn infer_literal_pattern() {
17..28 '{ loop {} }': T 17..28 '{ loop {} }': T
19..26 'loop {}': ! 19..26 'loop {}': !
24..26 '{}': () 24..26 '{}': ()
37..38 'x': &i32 37..38 'x': &'? i32
46..208 '{ ...) {} }': () 46..208 '{ ...) {} }': ()
52..75 'if let...y() {}': () 52..75 'if let...y() {}': ()
55..72 'let "f... any()': bool 55..72 'let "f... any()': bool
59..64 '"foo"': &str 59..64 '"foo"': &'static str
59..64 '"foo"': &str 59..64 '"foo"': &'static str
67..70 'any': fn any<&str>() -> &str 67..70 'any': fn any<&'static str>() -> &'static str
67..72 'any()': &str 67..72 'any()': &'static str
73..75 '{}': () 73..75 '{}': ()
80..99 'if let...y() {}': () 80..99 'if let...y() {}': ()
83..96 'let 1 = any()': bool 83..96 'let 1 = any()': bool
@ -178,7 +178,7 @@ fn infer_range_pattern() {
} }
"#, "#,
expect![[r#" expect![[r#"
8..9 'x': &i32 8..9 'x': &'? i32
17..75 '{ ...2 {} }': () 17..75 '{ ...2 {} }': ()
23..45 'if let...u32 {}': () 23..45 'if let...u32 {}': ()
26..42 'let 1....= 2u32': bool 26..42 'let 1....= 2u32': bool
@ -208,14 +208,14 @@ fn infer_pattern_match_ergonomics() {
expect![[r#" expect![[r#"
27..78 '{ ...(1); }': () 27..78 '{ ...(1); }': ()
37..41 'A(n)': A<i32> 37..41 'A(n)': A<i32>
39..40 'n': &i32 39..40 'n': &'? i32
44..49 '&A(1)': &A<i32> 44..49 '&A(1)': &'? A<i32>
45..46 'A': extern "rust-call" A<i32>(i32) -> A<i32> 45..46 'A': extern "rust-call" A<i32>(i32) -> A<i32>
45..49 'A(1)': A<i32> 45..49 'A(1)': A<i32>
47..48 '1': i32 47..48 '1': i32
59..63 'A(n)': A<i32> 59..63 'A(n)': A<i32>
61..62 'n': &mut i32 61..62 'n': &'? mut i32
66..75 '&mut A(1)': &mut A<i32> 66..75 '&mut A(1)': &'? mut A<i32>
71..72 'A': extern "rust-call" A<i32>(i32) -> A<i32> 71..72 'A': extern "rust-call" A<i32>(i32) -> A<i32>
71..75 'A(1)': A<i32> 71..75 'A(1)': A<i32>
73..74 '1': i32 73..74 '1': i32
@ -235,17 +235,17 @@ fn infer_pattern_match_ergonomics_ref() {
"#, "#,
expect![[r#" expect![[r#"
10..56 '{ ...= v; }': () 10..56 '{ ...= v; }': ()
20..21 'v': &(i32, &i32) 20..21 'v': &'? (i32, &'? i32)
24..32 '&(1, &2)': &(i32, &i32) 24..32 '&(1, &2)': &'? (i32, &'? i32)
25..32 '(1, &2)': (i32, &i32) 25..32 '(1, &2)': (i32, &'? i32)
26..27 '1': i32 26..27 '1': i32
29..31 '&2': &i32 29..31 '&2': &'? i32
30..31 '2': i32 30..31 '2': i32
42..49 '(_, &w)': (i32, &i32) 42..49 '(_, &w)': (i32, &'? i32)
43..44 '_': i32 43..44 '_': i32
46..48 '&w': &i32 46..48 '&w': &'? i32
47..48 'w': i32 47..48 'w': i32
52..53 'v': &(i32, &i32) 52..53 'v': &'? (i32, &'? i32)
"#]], "#]],
); );
} }
@ -286,28 +286,28 @@ fn infer_pattern_match_slice() {
"#, "#,
expect![[r#" expect![[r#"
10..209 '{ ... } }': () 10..209 '{ ... } }': ()
20..25 'slice': &[f64] 20..25 'slice': &'? [f64]
36..42 '&[0.0]': &[f64; 1] 36..42 '&[0.0]': &'? [f64; 1]
37..42 '[0.0]': [f64; 1] 37..42 '[0.0]': [f64; 1]
38..41 '0.0': f64 38..41 '0.0': f64
48..207 'match ... }': () 48..207 'match ... }': ()
54..59 'slice': &[f64] 54..59 'slice': &'? [f64]
70..73 '&[]': &[f64] 70..73 '&[]': &'? [f64]
71..73 '[]': [f64] 71..73 '[]': [f64]
77..79 '{}': () 77..79 '{}': ()
89..93 '&[a]': &[f64] 89..93 '&[a]': &'? [f64]
90..93 '[a]': [f64] 90..93 '[a]': [f64]
91..92 'a': f64 91..92 'a': f64
97..123 '{ ... }': () 97..123 '{ ... }': ()
111..112 'a': f64 111..112 'a': f64
133..140 '&[b, c]': &[f64] 133..140 '&[b, c]': &'? [f64]
134..140 '[b, c]': [f64] 134..140 '[b, c]': [f64]
135..136 'b': f64 135..136 'b': f64
138..139 'c': f64 138..139 'c': f64
144..185 '{ ... }': () 144..185 '{ ... }': ()
158..159 'b': f64 158..159 'b': f64
173..174 'c': f64 173..174 'c': f64
194..195 '_': &[f64] 194..195 '_': &'? [f64]
199..201 '{}': () 199..201 '{}': ()
"#]], "#]],
); );
@ -327,14 +327,14 @@ fn infer_pattern_match_string_literal() {
"#, "#,
expect![[r#" expect![[r#"
10..98 '{ ... } }': () 10..98 '{ ... } }': ()
20..21 's': &str 20..21 's': &'? str
30..37 '"hello"': &str 30..37 '"hello"': &'static str
43..96 'match ... }': () 43..96 'match ... }': ()
49..50 's': &str 49..50 's': &'? str
61..68 '"hello"': &str 61..68 '"hello"': &'static str
61..68 '"hello"': &str 61..68 '"hello"': &'static str
72..74 '{}': () 72..74 '{}': ()
83..84 '_': &str 83..84 '_': &'? str
88..90 '{}': () 88..90 '{}': ()
"#]], "#]],
); );
@ -358,27 +358,27 @@ fn infer_pattern_match_byte_string_literal() {
} }
"#, "#,
expect![[r#" expect![[r#"
105..109 'self': &[T; N] 105..109 'self': &'? [T; N]
111..116 'index': {unknown} 111..116 'index': {unknown}
157..180 '{ ... }': &[u8] 157..180 '{ ... }': &'? [u8]
167..174 'loop {}': ! 167..174 'loop {}': !
172..174 '{}': () 172..174 '{}': ()
191..192 'v': [u8; 3] 191..192 'v': [u8; 3]
203..261 '{ ...v {} }': () 203..261 '{ ...v {} }': ()
209..233 'if let...[S] {}': () 209..233 'if let...[S] {}': ()
212..230 'let b"... &v[S]': bool 212..230 'let b"... &v[S]': bool
216..222 'b"foo"': &[u8] 216..222 'b"foo"': &'static [u8]
216..222 'b"foo"': &[u8] 216..222 'b"foo"': &'static [u8]
225..230 '&v[S]': &[u8] 225..230 '&v[S]': &'? [u8]
226..227 'v': [u8; 3] 226..227 'v': [u8; 3]
226..230 'v[S]': [u8] 226..230 'v[S]': [u8]
228..229 'S': S 228..229 'S': S
231..233 '{}': () 231..233 '{}': ()
238..259 'if let... &v {}': () 238..259 'if let... &v {}': ()
241..256 'let b"foo" = &v': bool 241..256 'let b"foo" = &v': bool
245..251 'b"foo"': &[u8; 3] 245..251 'b"foo"': &'static [u8; 3]
245..251 'b"foo"': &[u8; 3] 245..251 'b"foo"': &'static [u8; 3]
254..256 '&v': &[u8; 3] 254..256 '&v': &'? [u8; 3]
255..256 'v': [u8; 3] 255..256 'v': [u8; 3]
257..259 '{}': () 257..259 '{}': ()
"#]], "#]],
@ -399,17 +399,17 @@ fn infer_pattern_match_or() {
"#, "#,
expect![[r#" expect![[r#"
10..108 '{ ... } }': () 10..108 '{ ... } }': ()
20..21 's': &str 20..21 's': &'? str
30..37 '"hello"': &str 30..37 '"hello"': &'static str
43..106 'match ... }': () 43..106 'match ... }': ()
49..50 's': &str 49..50 's': &'? str
61..68 '"hello"': &str 61..68 '"hello"': &'static str
61..68 '"hello"': &str 61..68 '"hello"': &'static str
61..78 '"hello...world"': &str 61..78 '"hello...world"': &'? str
71..78 '"world"': &str 71..78 '"world"': &'static str
71..78 '"world"': &str 71..78 '"world"': &'static str
82..84 '{}': () 82..84 '{}': ()
93..94 '_': &str 93..94 '_': &'? str
98..100 '{}': () 98..100 '{}': ()
"#]], "#]],
); );
@ -505,10 +505,10 @@ fn infer_adt_pattern() {
216..217 '1': usize 216..217 '1': usize
227..231 'E::B': E 227..231 'E::B': E
235..237 '10': usize 235..237 '10': usize
255..274 'ref d ...{ .. }': &E 255..274 'ref d ...{ .. }': &'? E
263..274 'E::A { .. }': E 263..274 'E::A { .. }': E
277..278 'e': E 277..278 'e': E
284..285 'd': &E 284..285 'd': &'? E
"#]], "#]],
); );
} }
@ -529,14 +529,14 @@ impl Foo {
expect![[r#" expect![[r#"
42..151 '{ ... }': () 42..151 '{ ... }': ()
56..64 'Self(s,)': Foo 56..64 'Self(s,)': Foo
61..62 's': &usize 61..62 's': &'? usize
67..75 '&Foo(0,)': &Foo 67..75 '&Foo(0,)': &'? Foo
68..71 'Foo': extern "rust-call" Foo(usize) -> Foo 68..71 'Foo': extern "rust-call" Foo(usize) -> Foo
68..75 'Foo(0,)': Foo 68..75 'Foo(0,)': Foo
72..73 '0': usize 72..73 '0': usize
89..97 'Self(s,)': Foo 89..97 'Self(s,)': Foo
94..95 's': &mut usize 94..95 's': &'? mut usize
100..112 '&mut Foo(0,)': &mut Foo 100..112 '&mut Foo(0,)': &'? mut Foo
105..108 'Foo': extern "rust-call" Foo(usize) -> Foo 105..108 'Foo': extern "rust-call" Foo(usize) -> Foo
105..112 'Foo(0,)': Foo 105..112 'Foo(0,)': Foo
109..110 '0': usize 109..110 '0': usize
@ -669,7 +669,7 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
27..31 'self': &S 27..31 'self': &'? S
41..50 '{ false }': bool 41..50 '{ false }': bool
43..48 'false': bool 43..48 'false': bool
64..115 '{ ... } }': () 64..115 '{ ... } }': ()
@ -679,7 +679,7 @@ fn main() {
93..94 's': S 93..94 's': S
93..100 's.foo()': bool 93..100 's.foo()': bool
104..106 '()': () 104..106 '()': ()
"#]], "#]],
) )
} }
@ -702,29 +702,29 @@ fn test() {
51..58 'loop {}': ! 51..58 'loop {}': !
56..58 '{}': () 56..58 '{}': ()
72..171 '{ ... x); }': () 72..171 '{ ... x); }': ()
78..81 'foo': fn foo<&(i32, &str), i32, impl FnOnce(&(i32, &str)) -> i32>(&(i32, &str), impl FnOnce(&(i32, &str)) -> i32) -> i32 78..81 'foo': fn foo<&'? (i32, &'? str), i32, impl FnOnce(&'? (i32, &'? str)) -> i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> i32) -> i32
78..105 'foo(&(...y)| x)': i32 78..105 'foo(&(...y)| x)': i32
82..91 '&(1, "a")': &(i32, &str) 82..91 '&(1, "a")': &'? (i32, &'static str)
83..91 '(1, "a")': (i32, &str) 83..91 '(1, "a")': (i32, &'static str)
84..85 '1': i32 84..85 '1': i32
87..90 '"a"': &str 87..90 '"a"': &'static str
93..104 '|&(x, y)| x': impl FnOnce(&(i32, &str)) -> i32 93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> i32
94..101 '&(x, y)': &(i32, &str) 94..101 '&(x, y)': &'? (i32, &'? str)
95..101 '(x, y)': (i32, &str) 95..101 '(x, y)': (i32, &'? str)
96..97 'x': i32 96..97 'x': i32
99..100 'y': &str 99..100 'y': &'? str
103..104 'x': i32 103..104 'x': i32
142..145 'foo': fn foo<&(i32, &str), &i32, impl FnOnce(&(i32, &str)) -> &i32>(&(i32, &str), impl FnOnce(&(i32, &str)) -> &i32) -> &i32 142..145 'foo': fn foo<&'? (i32, &'? str), &'? i32, impl FnOnce(&'? (i32, &'? str)) -> &'? i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> &'? i32) -> &'? i32
142..168 'foo(&(...y)| x)': &i32 142..168 'foo(&(...y)| x)': &'? i32
146..155 '&(1, "a")': &(i32, &str) 146..155 '&(1, "a")': &'? (i32, &'static str)
147..155 '(1, "a")': (i32, &str) 147..155 '(1, "a")': (i32, &'static str)
148..149 '1': i32 148..149 '1': i32
151..154 '"a"': &str 151..154 '"a"': &'static str
157..167 '|(x, y)| x': impl FnOnce(&(i32, &str)) -> &i32 157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> &'? i32
158..164 '(x, y)': (i32, &str) 158..164 '(x, y)': (i32, &'? str)
159..160 'x': &i32 159..160 'x': &'? i32
162..163 'y': &&str 162..163 'y': &'? &'? str
166..167 'x': &i32 166..167 'x': &'? i32
"#]], "#]],
); );
} }
@ -741,13 +741,13 @@ fn slice_tail_pattern() {
} }
"#, "#,
expect![[r#" expect![[r#"
7..13 'params': &[i32] 7..13 'params': &'? [i32]
23..92 '{ ... } }': () 23..92 '{ ... } }': ()
29..90 'match ... }': () 29..90 'match ... }': ()
35..41 'params': &[i32] 35..41 'params': &'? [i32]
52..69 '[head,... @ ..]': [i32] 52..69 '[head,... @ ..]': [i32]
53..57 'head': &i32 53..57 'head': &'? i32
59..68 'tail @ ..': &[i32] 59..68 'tail @ ..': &'? [i32]
66..68 '..': [i32] 66..68 '..': [i32]
73..84 '{ }': () 73..84 '{ }': ()
"#]], "#]],
@ -1109,7 +1109,7 @@ fn var_args() {
#[lang = "va_list"] #[lang = "va_list"]
pub struct VaListImpl<'f>; pub struct VaListImpl<'f>;
fn my_fn(foo: ...) {} fn my_fn(foo: ...) {}
//^^^ VaListImpl<'{error}> //^^^ VaListImpl<'?>
"#, "#,
); );
} }
@ -1122,9 +1122,9 @@ fn foo() {
let &() = &(); let &() = &();
let &mut () = &mut (); let &mut () = &mut ();
let &mut () = &(); let &mut () = &();
//^^^^^^^ expected &(), got &mut () //^^^^^^^ expected &'? (), got &'? mut ()
let &() = &mut (); let &() = &mut ();
//^^^ expected &mut (), got &() //^^^ expected &'? mut (), got &'? ()
} }
"#, "#,
); );
@ -1148,7 +1148,7 @@ fn main() {
}; };
if let Wrap::<X>::A { cool, ..} = &wrapped {} if let Wrap::<X>::A { cool, ..} = &wrapped {}
//^^^^ &u32 //^^^^ &'? u32
} }
"#, "#,
); );
@ -1182,7 +1182,7 @@ fn main() {
}; };
if let Wrap::<<S as Schematic>::Props>::A { cool, ..} = &wrapped {} if let Wrap::<<S as Schematic>::Props>::A { cool, ..} = &wrapped {}
//^^^^ &u32 //^^^^ &'? u32
} }
"#, "#,
); );
@ -1217,7 +1217,7 @@ fn main() {
match &6 { match &6 {
Foo::<i32>::TEST_I32_REF => (), Foo::<i32>::TEST_I32_REF => (),
Foo::<i32>::TEST_I32 => (), Foo::<i32>::TEST_I32 => (),
//^^^^^^^^^^^^^^^^^^^^ expected &i32, got i32 //^^^^^^^^^^^^^^^^^^^^ expected &'? i32, got i32
_ => (), _ => (),
} }
} }

148
crates/hir-ty/src/tests/regression.rs
View file

@ -99,7 +99,7 @@ fn recursive_vars() {
24..31 'unknown': {unknown} 24..31 'unknown': {unknown}
37..44 '[y, &y]': [{unknown}; 2] 37..44 '[y, &y]': [{unknown}; 2]
38..39 'y': {unknown} 38..39 'y': {unknown}
41..43 '&y': &{unknown} 41..43 '&y': &'? {unknown}
42..43 'y': {unknown} 42..43 'y': {unknown}
"#]], "#]],
); );
@ -117,19 +117,19 @@ fn recursive_vars_2() {
"#, "#,
expect![[r#" expect![[r#"
10..79 '{ ...x)]; }': () 10..79 '{ ...x)]; }': ()
20..21 'x': &{unknown} 20..21 'x': &'? {unknown}
24..31 'unknown': &{unknown} 24..31 'unknown': &'? {unknown}
41..42 'y': {unknown} 41..42 'y': {unknown}
45..52 'unknown': {unknown} 45..52 'unknown': {unknown}
58..76 '[(x, y..., &x)]': [(&{unknown}, {unknown}); 2] 58..76 '[(x, y..., &x)]': [(&'? {unknown}, {unknown}); 2]
59..65 '(x, y)': (&{unknown}, {unknown}) 59..65 '(x, y)': (&'? {unknown}, {unknown})
60..61 'x': &{unknown} 60..61 'x': &'? {unknown}
63..64 'y': {unknown} 63..64 'y': {unknown}
67..75 '(&y, &x)': (&{unknown}, {unknown}) 67..75 '(&y, &x)': (&'? {unknown}, {unknown})
68..70 '&y': &{unknown} 68..70 '&y': &'? {unknown}
69..70 'y': {unknown} 69..70 'y': {unknown}
72..74 '&x': &&{unknown} 72..74 '&x': &'? &'? {unknown}
73..74 'x': &{unknown} 73..74 'x': &'? {unknown}
"#]], "#]],
); );
} }
@ -166,7 +166,7 @@ fn infer_std_crash_1() {
59..136 'match ... }': () 59..136 'match ... }': ()
65..82 'someth...nknown': Maybe<{unknown}> 65..82 'someth...nknown': Maybe<{unknown}>
93..123 'Maybe:...thing)': Maybe<{unknown}> 93..123 'Maybe:...thing)': Maybe<{unknown}>
105..122 'ref mu...ething': &mut {unknown} 105..122 'ref mu...ething': &'? mut {unknown}
127..129 '()': () 127..129 '()': ()
"#]], "#]],
); );
@ -183,7 +183,7 @@ fn infer_std_crash_2() {
"#, "#,
expect![[r#" expect![[r#"
22..52 '{ ...n']; }': () 22..52 '{ ...n']; }': ()
28..49 '&[0, b...b'\n']': &[u8; 4] 28..49 '&[0, b...b'\n']': &'? [u8; 4]
29..49 '[0, b'...b'\n']': [u8; 4] 29..49 '[0, b'...b'\n']': [u8; 4]
30..31 '0': u8 30..31 '0': u8
33..38 'b'\n'': u8 33..38 'b'\n'': u8
@ -269,8 +269,8 @@ fn infer_std_crash_5() {
32..320 'for co... }': {unknown} 32..320 'for co... }': {unknown}
32..320 'for co... }': ! 32..320 'for co... }': !
32..320 'for co... }': {unknown} 32..320 'for co... }': {unknown}
32..320 'for co... }': &mut {unknown} 32..320 'for co... }': &'? mut {unknown}
32..320 'for co... }': fn next<{unknown}>(&mut {unknown}) -> Option<<{unknown} as Iterator>::Item> 32..320 'for co... }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
32..320 'for co... }': Option<{unknown}> 32..320 'for co... }': Option<{unknown}>
32..320 'for co... }': () 32..320 'for co... }': ()
32..320 'for co... }': () 32..320 'for co... }': ()
@ -278,22 +278,22 @@ fn infer_std_crash_5() {
36..43 'content': {unknown} 36..43 'content': {unknown}
47..60 'doesnt_matter': {unknown} 47..60 'doesnt_matter': {unknown}
61..320 '{ ... }': () 61..320 '{ ... }': ()
75..79 'name': &{unknown} 75..79 'name': &'? {unknown}
82..166 'if doe... }': &{unknown} 82..166 'if doe... }': &'? {unknown}
85..98 'doesnt_matter': bool 85..98 'doesnt_matter': bool
99..128 '{ ... }': &{unknown} 99..128 '{ ... }': &'? {unknown}
113..118 'first': &{unknown} 113..118 'first': &'? {unknown}
134..166 '{ ... }': &{unknown} 134..166 '{ ... }': &'? {unknown}
148..156 '&content': &{unknown} 148..156 '&content': &'? {unknown}
149..156 'content': {unknown} 149..156 'content': {unknown}
181..188 'content': &{unknown} 181..188 'content': &'? {unknown}
191..313 'if ICE... }': &{unknown} 191..313 'if ICE... }': &'? {unknown}
194..231 'ICE_RE..._VALUE': {unknown} 194..231 'ICE_RE..._VALUE': {unknown}
194..247 'ICE_RE...&name)': bool 194..247 'ICE_RE...&name)': bool
241..246 '&name': &&{unknown} 241..246 '&name': &'? &'? {unknown}
242..246 'name': &{unknown} 242..246 'name': &'? {unknown}
248..276 '{ ... }': &{unknown} 248..276 '{ ... }': &'? {unknown}
262..266 'name': &{unknown} 262..266 'name': &'? {unknown}
282..313 '{ ... }': {unknown} 282..313 '{ ... }': {unknown}
296..303 'content': {unknown} 296..303 'content': {unknown}
"#]], "#]],
@ -318,7 +318,7 @@ fn infer_nested_generics_crash() {
expect![[r#" expect![[r#"
91..105 'query_response': Canonical<QueryResponse<R>> 91..105 'query_response': Canonical<QueryResponse<R>>
136..166 '{ ...lue; }': () 136..166 '{ ...lue; }': ()
142..163 '&query....value': &QueryResponse<R> 142..163 '&query....value': &'? QueryResponse<R>
143..157 'query_response': Canonical<QueryResponse<R>> 143..157 'query_response': Canonical<QueryResponse<R>>
143..163 'query_....value': QueryResponse<R> 143..163 'query_....value': QueryResponse<R>
"#]], "#]],
@ -465,12 +465,12 @@ fn issue_3999_slice() {
} }
"#, "#,
expect![[r#" expect![[r#"
7..13 'params': &[usize] 7..13 'params': &'? [usize]
25..80 '{ ... } }': () 25..80 '{ ... } }': ()
31..78 'match ... }': () 31..78 'match ... }': ()
37..43 'params': &[usize] 37..43 'params': &'? [usize]
54..66 '[ps @ .., _]': [usize] 54..66 '[ps @ .., _]': [usize]
55..62 'ps @ ..': &[usize] 55..62 'ps @ ..': &'? [usize]
60..62 '..': [usize] 60..62 '..': [usize]
64..65 '_': usize 64..65 '_': usize
70..72 '{}': () 70..72 '{}': ()
@ -523,13 +523,13 @@ fn issue_4235_name_conflicts() {
"#, "#,
expect![[r#" expect![[r#"
31..37 'FOO {}': FOO 31..37 'FOO {}': FOO
63..67 'self': &FOO 63..67 'self': &'? FOO
69..71 '{}': () 69..71 '{}': ()
85..119 '{ ...o(); }': () 85..119 '{ ...o(); }': ()
95..96 'a': &FOO 95..96 'a': &'? FOO
99..103 '&FOO': &FOO 99..103 '&FOO': &'? FOO
100..103 'FOO': FOO 100..103 'FOO': FOO
109..110 'a': &FOO 109..110 'a': &'? FOO
109..116 'a.foo()': () 109..116 'a.foo()': ()
"#]], "#]],
); );
@ -715,12 +715,12 @@ fn issue_4885() {
} }
"#, "#,
expect![[r#" expect![[r#"
70..73 'key': &K 70..73 'key': &'? K
132..148 '{ ...key) }': impl Future<Output = <K as Foo<R>>::Bar> 132..148 '{ ...key) }': impl Future<Output = <K as Foo<R>>::Bar>
138..141 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar> 138..141 'bar': fn bar<R, K>(&'? K) -> impl Future<Output = <K as Foo<R>>::Bar>
138..146 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar> 138..146 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar>
142..145 'key': &K 142..145 'key': &'? K
162..165 'key': &K 162..165 'key': &'? K
224..227 '{ }': () 224..227 '{ }': ()
"#]], "#]],
); );
@ -771,11 +771,11 @@ fn issue_4800() {
} }
"#, "#,
expect![[r#" expect![[r#"
379..383 'self': &mut PeerSet<D> 379..383 'self': &'? mut PeerSet<D>
401..424 '{ ... }': dyn Future<Output = ()> 401..424 '{ ... }': dyn Future<Output = ()>
411..418 'loop {}': ! 411..418 'loop {}': !
416..418 '{}': () 416..418 '{}': ()
575..579 'self': &mut Self 575..579 'self': &'? mut Self
"#]], "#]],
); );
} }
@ -815,19 +815,19 @@ fn issue_4966() {
225..229 'iter': T 225..229 'iter': T
244..246 '{}': Vec<A> 244..246 '{}': Vec<A>
258..402 '{ ...r(); }': () 258..402 '{ ...r(); }': ()
268..273 'inner': Map<impl Fn(&f64) -> f64> 268..273 'inner': Map<impl Fn(&'? f64) -> f64>
276..300 'Map { ... 0.0 }': Map<impl Fn(&f64) -> f64> 276..300 'Map { ... 0.0 }': Map<impl Fn(&'? f64) -> f64>
285..298 '|_: &f64| 0.0': impl Fn(&f64) -> f64 285..298 '|_: &f64| 0.0': impl Fn(&'? f64) -> f64
286..287 '_': &f64 286..287 '_': &'? f64
295..298 '0.0': f64 295..298 '0.0': f64
311..317 'repeat': Repeat<Map<impl Fn(&f64) -> f64>> 311..317 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
320..345 'Repeat...nner }': Repeat<Map<impl Fn(&f64) -> f64>> 320..345 'Repeat...nner }': Repeat<Map<impl Fn(&'? f64) -> f64>>
338..343 'inner': Map<impl Fn(&f64) -> f64> 338..343 'inner': Map<impl Fn(&'? f64) -> f64>
356..359 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&f64) -> f64>>>> 356..359 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
362..371 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<impl Fn(&f64) -> f64>>>, Repeat<Map<impl Fn(&f64) -> f64>>>(Repeat<Map<impl Fn(&f64) -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<impl Fn(&f64) -> f64>>>> 362..371 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>, Repeat<Map<impl Fn(&'? f64) -> f64>>>(Repeat<Map<impl Fn(&'? f64) -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
362..379 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&f64) -> f64>>>> 362..379 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
372..378 'repeat': Repeat<Map<impl Fn(&f64) -> f64>> 372..378 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
386..389 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&f64) -> f64>>>> 386..389 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
386..399 'vec.foo_bar()': {unknown} 386..399 'vec.foo_bar()': {unknown}
"#]], "#]],
); );
@ -850,10 +850,10 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
40..44 'self': &S<T> 40..44 'self': &'? S<T>
46..48 '_t': T 46..48 '_t': T
53..55 '{}': () 53..55 '{}': ()
81..85 'self': &S<T> 81..85 'self': &'? S<T>
87..89 '_f': F 87..89 '_f': F
94..96 '{}': () 94..96 '{}': ()
109..160 '{ ...10); }': () 109..160 '{ ...10); }': ()
@ -862,8 +862,8 @@ fn main() {
123..126 'S()': S<i32> 123..126 'S()': S<i32>
132..133 's': S<i32> 132..133 's': S<i32>
132..144 's.g(|_x| {})': () 132..144 's.g(|_x| {})': ()
136..143 '|_x| {}': impl FnOnce(&i32) 136..143 '|_x| {}': impl FnOnce(&'? i32)
137..139 '_x': &i32 137..139 '_x': &'? i32
141..143 '{}': () 141..143 '{}': ()
150..151 's': S<i32> 150..151 's': S<i32>
150..157 's.f(10)': () 150..157 's.f(10)': ()
@ -895,14 +895,14 @@ fn flush(&self) {
} }
"#, "#,
expect![[r#" expect![[r#"
123..127 'self': &Mutex<T> 123..127 'self': &'? Mutex<T>
150..152 '{}': MutexGuard<'{error}, T> 150..152 '{}': MutexGuard<'?, T>
234..238 'self': &{unknown} 234..238 'self': &'? {unknown}
240..290 '{ ...()); }': () 240..290 '{ ...()); }': ()
250..251 'w': &Mutex<BufWriter> 250..251 'w': &'? Mutex<BufWriter>
276..287 '*(w.lock())': BufWriter 276..287 '*(w.lock())': BufWriter
278..279 'w': &Mutex<BufWriter> 278..279 'w': &'? Mutex<BufWriter>
278..286 'w.lock()': MutexGuard<'{error}, BufWriter> 278..286 'w.lock()': MutexGuard<'?, BufWriter>
"#]], "#]],
); );
} }
@ -1023,20 +1023,20 @@ fn cfg_tail() {
expect![[r#" expect![[r#"
14..53 '{ ...)] 9 }': () 14..53 '{ ...)] 9 }': ()
20..31 '{ "first" }': () 20..31 '{ "first" }': ()
22..29 '"first"': &str 22..29 '"first"': &'static str
72..190 '{ ...] 13 }': () 72..190 '{ ...] 13 }': ()
78..88 '{ "fake" }': () 78..88 '{ "fake" }': ()
80..86 '"fake"': &str 80..86 '"fake"': &'static str
93..103 '{ "fake" }': () 93..103 '{ "fake" }': ()
95..101 '"fake"': &str 95..101 '"fake"': &'static str
108..120 '{ "second" }': () 108..120 '{ "second" }': ()
110..118 '"second"': &str 110..118 '"second"': &'static str
210..273 '{ ... 15; }': () 210..273 '{ ... 15; }': ()
216..227 '{ "third" }': () 216..227 '{ "third" }': ()
218..225 '"third"': &str 218..225 '"third"': &'static str
293..357 '{ ...] 15 }': () 293..357 '{ ...] 15 }': ()
299..311 '{ "fourth" }': &str 299..311 '{ "fourth" }': &'static str
301..309 '"fourth"': &str 301..309 '"fourth"': &'static str
"#]], "#]],
) )
} }
@ -1238,8 +1238,8 @@ fn test() {
16..66 'for _ ... }': IntoIterator::IntoIter<()> 16..66 'for _ ... }': IntoIterator::IntoIter<()>
16..66 'for _ ... }': ! 16..66 'for _ ... }': !
16..66 'for _ ... }': IntoIterator::IntoIter<()> 16..66 'for _ ... }': IntoIterator::IntoIter<()>
16..66 'for _ ... }': &mut IntoIterator::IntoIter<()> 16..66 'for _ ... }': &'? mut IntoIterator::IntoIter<()>
16..66 'for _ ... }': fn next<IntoIterator::IntoIter<()>>(&mut IntoIterator::IntoIter<()>) -> Option<<IntoIterator::IntoIter<()> as Iterator>::Item> 16..66 'for _ ... }': fn next<IntoIterator::IntoIter<()>>(&'? mut IntoIterator::IntoIter<()>) -> Option<<IntoIterator::IntoIter<()> as Iterator>::Item>
16..66 'for _ ... }': Option<IntoIterator::Item<()>> 16..66 'for _ ... }': Option<IntoIterator::Item<()>>
16..66 'for _ ... }': () 16..66 'for _ ... }': ()
16..66 'for _ ... }': () 16..66 'for _ ... }': ()
@ -1727,7 +1727,7 @@ fn dyn_with_unresolved_trait() {
r#" r#"
fn foo(a: &dyn DoesNotExist) { fn foo(a: &dyn DoesNotExist) {
a.bar(); a.bar();
//^&{unknown} //^&'? {unknown}
} }
"#, "#,
); );
@ -1851,9 +1851,9 @@ fn foo() {
match &E::A { match &E::A {
b @ (x @ E::A | x) => { b @ (x @ E::A | x) => {
b; b;
//^ &E //^ &'? E
x; x;
//^ &E //^ &'? E
} }
} }
}", }",

418
crates/hir-ty/src/tests/simple.rs
View file

@ -115,15 +115,15 @@ fn test(a: u32, b: isize, c: !, d: &str) {
8..9 'a': u32 8..9 'a': u32
16..17 'b': isize 16..17 'b': isize
26..27 'c': ! 26..27 'c': !
32..33 'd': &str 32..33 'd': &'? str
41..120 '{ ...f32; }': () 41..120 '{ ...f32; }': ()
47..48 'a': u32 47..48 'a': u32
54..55 'b': isize 54..55 'b': isize
61..62 'c': ! 61..62 'c': !
68..69 'd': &str 68..69 'd': &'? str
75..81 '1usize': usize 75..81 '1usize': usize
87..93 '1isize': isize 87..93 '1isize': isize
99..105 '"test"': &str 99..105 '"test"': &'static str
111..117 '1.0f32': f32 111..117 '1.0f32': f32
"#]], "#]],
); );
@ -344,23 +344,23 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
} }
"#, "#,
expect![[r#" expect![[r#"
8..9 'a': &u32 8..9 'a': &'? u32
17..18 'b': &mut u32 17..18 'b': &'? mut u32
30..31 'c': *const u32 30..31 'c': *const u32
45..46 'd': *mut u32 45..46 'd': *mut u32
58..149 '{ ... *d; }': () 58..149 '{ ... *d; }': ()
64..65 'a': &u32 64..65 'a': &'? u32
71..73 '*a': u32 71..73 '*a': u32
72..73 'a': &u32 72..73 'a': &'? u32
79..81 '&a': &&u32 79..81 '&a': &'? &'? u32
80..81 'a': &u32 80..81 'a': &'? u32
87..93 '&mut a': &mut &u32 87..93 '&mut a': &'? mut &'? u32
92..93 'a': &u32 92..93 'a': &'? u32
99..100 'b': &mut u32 99..100 'b': &'? mut u32
106..108 '*b': u32 106..108 '*b': u32
107..108 'b': &mut u32 107..108 'b': &'? mut u32
114..116 '&b': &&mut u32 114..116 '&b': &'? &'? mut u32
115..116 'b': &mut u32 115..116 'b': &'? mut u32
122..123 'c': *const u32 122..123 'c': *const u32
129..131 '*c': u32 129..131 '*c': u32
130..131 'c': *const u32 130..131 'c': *const u32
@ -425,22 +425,22 @@ h";
32..36 '5i32': i32 32..36 '5i32': i32
50..54 '5f32': f32 50..54 '5f32': f32
68..72 '5f64': f64 68..72 '5f64': f64
86..93 '"hello"': &str 86..93 '"hello"': &'static str
107..115 'b"bytes"': &[u8; 5] 107..115 'b"bytes"': &'static [u8; 5]
129..132 ''c'': char 129..132 ''c'': char
146..150 'b'b'': u8 146..150 'b'b'': u8
164..168 '3.14': f64 164..168 '3.14': f64
182..186 '5000': i32 182..186 '5000': i32
200..205 'false': bool 200..205 'false': bool
219..223 'true': bool 219..223 'true': bool
237..333 'r#" ... "#': &str 237..333 'r#" ... "#': &'static str
347..357 'br#"yolo"#': &[u8; 4] 347..357 'br#"yolo"#': &'static [u8; 4]
375..376 'a': &[u8; 4] 375..376 'a': &'static [u8; 4]
379..403 'b"a\x2... c"': &[u8; 4] 379..403 'b"a\x2... c"': &'static [u8; 4]
421..422 'b': &[u8; 4] 421..422 'b': &'static [u8; 4]
425..433 'br"g\ h"': &[u8; 4] 425..433 'br"g\ h"': &'static [u8; 4]
451..452 'c': &[u8; 6] 451..452 'c': &'static [u8; 6]
455..467 'br#"x"\"yb"#': &[u8; 6] 455..467 'br#"x"\"yb"#': &'static [u8; 6]
"##]], "##]],
); );
} }
@ -508,9 +508,9 @@ fn test(x: SomeType) {
238..240 '!x': {unknown} 238..240 '!x': {unknown}
239..240 'x': SomeType 239..240 'x': SomeType
246..254 '-"hello"': {unknown} 246..254 '-"hello"': {unknown}
247..254 '"hello"': &str 247..254 '"hello"': &'static str
260..268 '!"hello"': {unknown} 260..268 '!"hello"': {unknown}
261..268 '"hello"': &str 261..268 '"hello"': &'static str
"#]], "#]],
); );
} }
@ -535,7 +535,7 @@ fn test() -> &mut &f64 {
expect![[r#" expect![[r#"
13..14 'x': u32 13..14 'x': u32
21..23 '{}': () 21..23 '{}': ()
77..230 '{ ...t &c }': &mut &f64 77..230 '{ ...t &c }': &'? mut &'? f64
87..88 'a': u32 87..88 'a': u32
91..107 'unknow...nction': {unknown} 91..107 'unknow...nction': {unknown}
91..109 'unknow...tion()': u32 91..109 'unknow...tion()': u32
@ -550,8 +550,8 @@ fn test() -> &mut &f64 {
193..194 'c': f64 193..194 'c': f64
197..213 'unknow...nction': {unknown} 197..213 'unknow...nction': {unknown}
197..215 'unknow...tion()': f64 197..215 'unknow...tion()': f64
221..228 '&mut &c': &mut &f64 221..228 '&mut &c': &'? mut &'? f64
226..228 '&c': &f64 226..228 '&c': &'? f64
227..228 'c': f64 227..228 'c': f64
"#]], "#]],
); );
@ -579,12 +579,12 @@ impl S {
} }
"#, "#,
expect![[r#" expect![[r#"
33..37 'self': &S 33..37 'self': &'? S
39..60 '{ ... }': () 39..60 '{ ... }': ()
49..53 'self': &S 49..53 'self': &'? S
74..78 'self': &S 74..78 'self': &'? S
87..108 '{ ... }': () 87..108 '{ ... }': ()
97..101 'self': &S 97..101 'self': &'? S
132..152 '{ ... }': S 132..152 '{ ... }': S
142..146 'S {}': S 142..146 'S {}': S
176..199 '{ ... }': S 176..199 '{ ... }': S
@ -771,35 +771,35 @@ fn test2(a1: *const A, a2: *mut A) {
64..65 'a': A 64..65 'a': A
71..73 'a1': A 71..73 'a1': A
71..75 'a1.b': B 71..75 'a1.b': B
85..87 'a2': &A 85..87 'a2': &'? A
90..92 '&a': &A 90..92 '&a': &'? A
91..92 'a': A 91..92 'a': A
98..100 'a2': &A 98..100 'a2': &'? A
98..102 'a2.b': B 98..102 'a2.b': B
112..114 'a3': &mut A 112..114 'a3': &'? mut A
117..123 '&mut a': &mut A 117..123 '&mut a': &'? mut A
122..123 'a': A 122..123 'a': A
129..131 'a3': &mut A 129..131 'a3': &'? mut A
129..133 'a3.b': B 129..133 'a3.b': B
143..145 'a4': &&&&&&&A 143..145 'a4': &'? &'? &'? &'? &'? &'? &'? A
148..156 '&&&&&&&a': &&&&&&&A 148..156 '&&&&&&&a': &'? &'? &'? &'? &'? &'? &'? A
149..156 '&&&&&&a': &&&&&&A 149..156 '&&&&&&a': &'? &'? &'? &'? &'? &'? A
150..156 '&&&&&a': &&&&&A 150..156 '&&&&&a': &'? &'? &'? &'? &'? A
151..156 '&&&&a': &&&&A 151..156 '&&&&a': &'? &'? &'? &'? A
152..156 '&&&a': &&&A 152..156 '&&&a': &'? &'? &'? A
153..156 '&&a': &&A 153..156 '&&a': &'? &'? A
154..156 '&a': &A 154..156 '&a': &'? A
155..156 'a': A 155..156 'a': A
162..164 'a4': &&&&&&&A 162..164 'a4': &'? &'? &'? &'? &'? &'? &'? A
162..166 'a4.b': B 162..166 'a4.b': B
176..178 'a5': &mut &&mut &&mut A 176..178 'a5': &'? mut &'? &'? mut &'? &'? mut A
181..199 '&mut &...&mut a': &mut &&mut &&mut A 181..199 '&mut &...&mut a': &'? mut &'? &'? mut &'? &'? mut A
186..199 '&&mut &&mut a': &&mut &&mut A 186..199 '&&mut &&mut a': &'? &'? mut &'? &'? mut A
187..199 '&mut &&mut a': &mut &&mut A 187..199 '&mut &&mut a': &'? mut &'? &'? mut A
192..199 '&&mut a': &&mut A 192..199 '&&mut a': &'? &'? mut A
193..199 '&mut a': &mut A 193..199 '&mut a': &'? mut A
198..199 'a': A 198..199 'a': A
205..207 'a5': &mut &&mut &&mut A 205..207 'a5': &'? mut &'? &'? mut &'? &'? mut A
205..209 'a5.b': B 205..209 'a5.b': B
223..225 'a1': *const A 223..225 'a1': *const A
237..239 'a2': *mut A 237..239 'a2': *mut A
@ -840,22 +840,22 @@ fn test() {
} }
"#, "#,
expect![[r#" expect![[r#"
66..70 'self': &A<T> 66..70 'self': &'? A<T>
78..101 '{ ... }': &T 78..101 '{ ... }': &'? T
88..95 '&self.0': &T 88..95 '&self.0': &'? T
89..93 'self': &A<T> 89..93 'self': &'? A<T>
89..95 'self.0': T 89..95 'self.0': T
182..186 'self': &B<T> 182..186 'self': &'? B<T>
205..228 '{ ... }': &T 205..228 '{ ... }': &'? T
215..222 '&self.0': &T 215..222 '&self.0': &'? T
216..220 'self': &B<T> 216..220 'self': &'? B<T>
216..222 'self.0': T 216..222 'self.0': T
242..280 '{ ...))); }': () 242..280 '{ ...))); }': ()
252..253 't': &i32 252..253 't': &'? i32
256..262 'A::foo': fn foo<i32>(&A<i32>) -> &i32 256..262 'A::foo': fn foo<i32>(&'? A<i32>) -> &'? i32
256..277 'A::foo...42))))': &i32 256..277 'A::foo...42))))': &'? i32
263..276 '&&B(B(A(42)))': &&B<B<A<i32>>> 263..276 '&&B(B(A(42)))': &'? &'? B<B<A<i32>>>
264..276 '&B(B(A(42)))': &B<B<A<i32>>> 264..276 '&B(B(A(42)))': &'? B<B<A<i32>>>
265..266 'B': extern "rust-call" B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> 265..266 'B': extern "rust-call" B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
265..276 'B(B(A(42)))': B<B<A<i32>>> 265..276 'B(B(A(42)))': B<B<A<i32>>>
267..268 'B': extern "rust-call" B<A<i32>>(A<i32>) -> B<A<i32>> 267..268 'B': extern "rust-call" B<A<i32>>(A<i32>) -> B<A<i32>>
@ -895,28 +895,28 @@ fn test(a: A<i32>) {
} }
"#, "#,
expect![[r#" expect![[r#"
71..75 'self': &A<T> 71..75 'self': &'? A<T>
77..78 'x': &A<T> 77..78 'x': &'? A<T>
93..114 '{ ... }': &T 93..114 '{ ... }': &'? T
103..108 '&*x.0': &T 103..108 '&*x.0': &'? T
104..108 '*x.0': T 104..108 '*x.0': T
105..106 'x': &A<T> 105..106 'x': &'? A<T>
105..108 'x.0': *mut T 105..108 'x.0': *mut T
195..199 'self': &B<T> 195..199 'self': &'? B<T>
218..241 '{ ... }': &T 218..241 '{ ... }': &'? T
228..235 '&self.0': &T 228..235 '&self.0': &'? T
229..233 'self': &B<T> 229..233 'self': &'? B<T>
229..235 'self.0': T 229..235 'self.0': T
253..254 'a': A<i32> 253..254 'a': A<i32>
264..310 '{ ...))); }': () 264..310 '{ ...))); }': ()
274..275 't': &i32 274..275 't': &'? i32
278..279 'A': extern "rust-call" A<i32>(*mut i32) -> A<i32> 278..279 'A': extern "rust-call" A<i32>(*mut i32) -> A<i32>
278..292 'A(0 as *mut _)': A<i32> 278..292 'A(0 as *mut _)': A<i32>
278..307 'A(0 as...B(a)))': &i32 278..307 'A(0 as...B(a)))': &'? i32
280..281 '0': i32 280..281 '0': i32
280..291 '0 as *mut _': *mut i32 280..291 '0 as *mut _': *mut i32
297..306 '&&B(B(a))': &&B<B<A<i32>>> 297..306 '&&B(B(a))': &'? &'? B<B<A<i32>>>
298..306 '&B(B(a))': &B<B<A<i32>>> 298..306 '&B(B(a))': &'? B<B<A<i32>>>
299..300 'B': extern "rust-call" B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> 299..300 'B': extern "rust-call" B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
299..306 'B(B(a))': B<B<A<i32>>> 299..306 'B(B(a))': B<B<A<i32>>>
301..302 'B': extern "rust-call" B<A<i32>>(A<i32>) -> B<A<i32>> 301..302 'B': extern "rust-call" B<A<i32>>(A<i32>) -> B<A<i32>>
@ -1044,7 +1044,7 @@ fn infer_inherent_method() {
31..35 'self': A 31..35 'self': A
37..38 'x': u32 37..38 'x': u32
52..54 '{}': i32 52..54 '{}': i32
106..110 'self': &A 106..110 'self': &'? A
112..113 'x': u64 112..113 'x': u64
127..129 '{}': i64 127..129 '{}': i64
147..148 'a': A 147..148 'a': A
@ -1053,7 +1053,7 @@ fn infer_inherent_method() {
159..167 'a.foo(1)': i32 159..167 'a.foo(1)': i32
165..166 '1': u32 165..166 '1': u32
173..184 '(&a).bar(1)': i64 173..184 '(&a).bar(1)': i64
174..176 '&a': &A 174..176 '&a': &'? A
175..176 'a': A 175..176 'a': A
182..183 '1': u64 182..183 '1': u64
190..191 'a': A 190..191 'a': A
@ -1078,10 +1078,10 @@ fn test() {
} }
"#, "#,
expect![[r#" expect![[r#"
67..71 'self': &str 67..71 'self': &'? str
80..82 '{}': i32 80..82 '{}': i32
96..116 '{ ...o(); }': () 96..116 '{ ...o(); }': ()
102..107 '"foo"': &str 102..107 '"foo"': &'static str
102..113 '"foo".foo()': i32 102..113 '"foo".foo()': i32
"#]], "#]],
); );
@ -1101,33 +1101,33 @@ fn infer_tuple() {
} }
"#, "#,
expect![[r#" expect![[r#"
8..9 'x': &str 8..9 'x': &'? str
17..18 'y': isize 17..18 'y': isize
27..169 '{ ...d"); }': () 27..169 '{ ...d"); }': ()
37..38 'a': (u32, &str) 37..38 'a': (u32, &'? str)
54..62 '(1, "a")': (u32, &str) 54..62 '(1, "a")': (u32, &'? str)
55..56 '1': u32 55..56 '1': u32
58..61 '"a"': &str 58..61 '"a"': &'static str
72..73 'b': ((u32, &str), &str) 72..73 'b': ((u32, &'? str), &'? str)
76..82 '(a, x)': ((u32, &str), &str) 76..82 '(a, x)': ((u32, &'? str), &'? str)
77..78 'a': (u32, &str) 77..78 'a': (u32, &'? str)
80..81 'x': &str 80..81 'x': &'? str
92..93 'c': (isize, &str) 92..93 'c': (isize, &'? str)
96..102 '(y, x)': (isize, &str) 96..102 '(y, x)': (isize, &'? str)
97..98 'y': isize 97..98 'y': isize
100..101 'x': &str 100..101 'x': &'? str
112..113 'd': ((isize, &str), &str) 112..113 'd': ((isize, &'? str), &'? str)
116..122 '(c, x)': ((isize, &str), &str) 116..122 '(c, x)': ((isize, &'? str), &'? str)
117..118 'c': (isize, &str) 117..118 'c': (isize, &'? str)
120..121 'x': &str 120..121 'x': &'? str
132..133 'e': (i32, &str) 132..133 'e': (i32, &'static str)
136..144 '(1, "e")': (i32, &str) 136..144 '(1, "e")': (i32, &'static str)
137..138 '1': i32 137..138 '1': i32
140..143 '"e"': &str 140..143 '"e"': &'static str
154..155 'f': ((i32, &str), &str) 154..155 'f': ((i32, &'static str), &'static str)
158..166 '(e, "d")': ((i32, &str), &str) 158..166 '(e, "d")': ((i32, &'static str), &'static str)
159..160 'e': (i32, &str) 159..160 'e': (i32, &'static str)
162..165 '"d"': &str 162..165 '"d"': &'static str
"#]], "#]],
); );
} }
@ -1156,20 +1156,20 @@ fn infer_array() {
} }
"#, "#,
expect![[r#" expect![[r#"
8..9 'x': &str 8..9 'x': &'? str
17..18 'y': isize 17..18 'y': isize
27..326 '{ ...,4]; }': () 27..326 '{ ...,4]; }': ()
37..38 'a': [&str; 1] 37..38 'a': [&'? str; 1]
41..44 '[x]': [&str; 1] 41..44 '[x]': [&'? str; 1]
42..43 'x': &str 42..43 'x': &'? str
54..55 'b': [[&str; 1]; 2] 54..55 'b': [[&'? str; 1]; 2]
58..64 '[a, a]': [[&str; 1]; 2] 58..64 '[a, a]': [[&'? str; 1]; 2]
59..60 'a': [&str; 1] 59..60 'a': [&'? str; 1]
62..63 'a': [&str; 1] 62..63 'a': [&'? str; 1]
74..75 'c': [[[&str; 1]; 2]; 2] 74..75 'c': [[[&'? str; 1]; 2]; 2]
78..84 '[b, b]': [[[&str; 1]; 2]; 2] 78..84 '[b, b]': [[[&'? str; 1]; 2]; 2]
79..80 'b': [[&str; 1]; 2] 79..80 'b': [[&'? str; 1]; 2]
82..83 'b': [[&str; 1]; 2] 82..83 'b': [[&'? str; 1]; 2]
95..96 'd': [isize; 4] 95..96 'd': [isize; 4]
99..111 '[y, 1, 2, 3]': [isize; 4] 99..111 '[y, 1, 2, 3]': [isize; 4]
100..101 'y': isize 100..101 'y': isize
@ -1197,15 +1197,15 @@ fn infer_array() {
209..215 '[1, 2]': [i32; 2] 209..215 '[1, 2]': [i32; 2]
210..211 '1': i32 210..211 '1': i32
213..214 '2': i32 213..214 '2': i32
225..226 'i': [&str; 2] 225..226 'i': [&'? str; 2]
229..239 '["a", "b"]': [&str; 2] 229..239 '["a", "b"]': [&'? str; 2]
230..233 '"a"': &str 230..233 '"a"': &'static str
235..238 '"b"': &str 235..238 '"b"': &'static str
250..251 'b': [[&str; 1]; 2] 250..251 'b': [[&'? str; 1]; 2]
254..264 '[a, ["b"]]': [[&str; 1]; 2] 254..264 '[a, ["b"]]': [[&'? str; 1]; 2]
255..256 'a': [&str; 1] 255..256 'a': [&'? str; 1]
258..263 '["b"]': [&str; 1] 258..263 '["b"]': [&'? str; 1]
259..262 '"b"': &str 259..262 '"b"': &'static str
274..275 'x': [u8; 0] 274..275 'x': [u8; 0]
287..289 '[]': [u8; 0] 287..289 '[]': [u8; 0]
299..300 'y': [u8; 4] 299..300 'y': [u8; 4]
@ -1279,12 +1279,12 @@ fn infer_tuple_struct_generics() {
92..93 'A': extern "rust-call" A<u128>(u128) -> A<u128> 92..93 'A': extern "rust-call" A<u128>(u128) -> A<u128>
92..101 'A(42u128)': A<u128> 92..101 'A(42u128)': A<u128>
94..100 '42u128': u128 94..100 '42u128': u128
107..111 'Some': extern "rust-call" Some<&str>(&str) -> Option<&str> 107..111 'Some': extern "rust-call" Some<&'static str>(&'static str) -> Option<&'static str>
107..116 'Some("x")': Option<&str> 107..116 'Some("x")': Option<&'static str>
112..115 '"x"': &str 112..115 '"x"': &'static str
122..134 'Option::Some': extern "rust-call" Some<&str>(&str) -> Option<&str> 122..134 'Option::Some': extern "rust-call" Some<&'static str>(&'static str) -> Option<&'static str>
122..139 'Option...e("x")': Option<&str> 122..139 'Option...e("x")': Option<&'static str>
135..138 '"x"': &str 135..138 '"x"': &'static str
145..149 'None': Option<{unknown}> 145..149 'None': Option<{unknown}>
159..160 'x': Option<i64> 159..160 'x': Option<i64>
176..180 'None': Option<i64> 176..180 'None': Option<i64>
@ -1405,15 +1405,15 @@ fn infer_impl_generics_with_autoderef() {
} }
"#, "#,
expect![[r#" expect![[r#"
77..81 'self': &Option<T> 77..81 'self': &'? Option<T>
97..99 '{}': Option<&T> 97..99 '{}': Option<&'? T>
110..111 'o': Option<u32> 110..111 'o': Option<u32>
126..164 '{ ...f(); }': () 126..164 '{ ...f(); }': ()
132..145 '(&o).as_ref()': Option<&u32> 132..145 '(&o).as_ref()': Option<&'? u32>
133..135 '&o': &Option<u32> 133..135 '&o': &'? Option<u32>
134..135 'o': Option<u32> 134..135 'o': Option<u32>
151..152 'o': Option<u32> 151..152 'o': Option<u32>
151..161 'o.as_ref()': Option<&u32> 151..161 'o.as_ref()': Option<&'? u32>
"#]], "#]],
); );
} }
@ -1551,16 +1551,16 @@ fn infer_type_alias() {
"#, "#,
expect![[r#" expect![[r#"
115..116 'x': A<u32, i128> 115..116 'x': A<u32, i128>
123..124 'y': A<&str, u128> 123..124 'y': A<&'? str, u128>
137..138 'z': A<u8, i8> 137..138 'z': A<u8, i8>
153..210 '{ ...z.y; }': () 153..210 '{ ...z.y; }': ()
159..160 'x': A<u32, i128> 159..160 'x': A<u32, i128>
159..162 'x.x': u32 159..162 'x.x': u32
168..169 'x': A<u32, i128> 168..169 'x': A<u32, i128>
168..171 'x.y': i128 168..171 'x.y': i128
177..178 'y': A<&str, u128> 177..178 'y': A<&'? str, u128>
177..180 'y.x': &str 177..180 'y.x': &'? str
186..187 'y': A<&str, u128> 186..187 'y': A<&'? str, u128>
186..189 'y.y': u128 186..189 'y.y': u128
195..196 'z': A<u8, i8> 195..196 'z': A<u8, i8>
195..198 'z.x': u8 195..198 'z.x': u8
@ -1572,8 +1572,8 @@ fn infer_type_alias() {
312..328 'm::Ali...Foo(0)': Enum 312..328 'm::Ali...Foo(0)': Enum
326..327 '0': u8 326..327 '0': u8
338..354 'm::Ali...Foo(x)': Enum 338..354 'm::Ali...Foo(x)': Enum
352..353 'x': &u8 352..353 'x': &'? u8
357..359 '&e': &Enum 357..359 '&e': &'? Enum
358..359 'e': Enum 358..359 'e': Enum
"#]], "#]],
) )
@ -1618,10 +1618,10 @@ fn infer_type_param() {
9..10 'x': T 9..10 'x': T
20..29 '{ x }': T 20..29 '{ x }': T
26..27 'x': T 26..27 'x': T
43..44 'x': &T 43..44 'x': &'? T
55..65 '{ *x }': T 55..65 '{ *x }': T
61..63 '*x': T 61..63 '*x': T
62..63 'x': &T 62..63 'x': &'? T
77..157 '{ ...(1); }': () 77..157 '{ ...(1); }': ()
87..88 'y': u32 87..88 'y': u32
91..96 '10u32': u32 91..96 '10u32': u32
@ -1629,9 +1629,9 @@ fn infer_type_param() {
102..107 'id(y)': u32 102..107 'id(y)': u32
105..106 'y': u32 105..106 'y': u32
117..118 'x': bool 117..118 'x': bool
127..132 'clone': fn clone<bool>(&bool) -> bool 127..132 'clone': fn clone<bool>(&'? bool) -> bool
127..135 'clone(z)': bool 127..135 'clone(z)': bool
133..134 'z': &bool 133..134 'z': &'? bool
141..151 'id::<i128>': fn id<i128>(i128) -> i128 141..151 'id::<i128>': fn id<i128>(i128) -> i128
141..154 'id::<i128>(1)': i128 141..154 'id::<i128>(1)': i128
152..153 '1': i128 152..153 '1': i128
@ -1842,7 +1842,7 @@ fn foo() -> &'static str { "" }
fn main() { fn main() {
foo(); foo();
//^^^^^ &str //^^^^^ &'static str
}"#, }"#,
); );
} }
@ -1940,10 +1940,10 @@ fn closure_return_inferred() {
"#, "#,
expect![[r#" expect![[r#"
16..46 '{ ..." }; }': u32 16..46 '{ ..." }; }': u32
26..27 'x': impl Fn() -> &str 26..27 'x': impl Fn() -> &'static str
30..43 '|| { "test" }': impl Fn() -> &str 30..43 '|| { "test" }': impl Fn() -> &'static str
33..43 '{ "test" }': &str 33..43 '{ "test" }': &'static str
35..41 '"test"': &str 35..41 '"test"': &'static str
"#]], "#]],
); );
} }
@ -1975,10 +1975,10 @@ fn test() {
70..71 'v': i64 70..71 'v': i64
78..80 '{}': () 78..80 '{}': ()
91..362 '{ ... } }': () 91..362 '{ ... } }': ()
101..106 'mut g': |usize| yields i64 -> &str 101..106 'mut g': |usize| yields i64 -> &'static str
109..218 '|r| { ... }': |usize| yields i64 -> &str 109..218 '|r| { ... }': |usize| yields i64 -> &'static str
110..111 'r': usize 110..111 'r': usize
113..218 '{ ... }': &str 113..218 '{ ... }': &'static str
127..128 'a': usize 127..128 'a': usize
131..138 'yield 0': usize 131..138 'yield 0': usize
137..138 '0': i64 137..138 '0': i64
@ -1988,22 +1988,22 @@ fn test() {
177..178 'a': usize 177..178 'a': usize
181..188 'yield 2': usize 181..188 'yield 2': usize
187..188 '2': i64 187..188 '2': i64
198..212 '"return value"': &str 198..212 '"return value"': &'static str
225..360 'match ... }': () 225..360 'match ... }': ()
231..239 'Pin::new': fn new<&mut |usize| yields i64 -> &str>(&mut |usize| yields i64 -> &str) -> Pin<&mut |usize| yields i64 -> &str> 231..239 'Pin::new': fn new<&'? mut |usize| yields i64 -> &'static str>(&'? mut |usize| yields i64 -> &'static str) -> Pin<&'? mut |usize| yields i64 -> &'static str>
231..247 'Pin::n...mut g)': Pin<&mut |usize| yields i64 -> &str> 231..247 'Pin::n...mut g)': Pin<&'? mut |usize| yields i64 -> &'static str>
231..262 'Pin::n...usize)': CoroutineState<i64, &str> 231..262 'Pin::n...usize)': CoroutineState<i64, &'static str>
240..246 '&mut g': &mut |usize| yields i64 -> &str 240..246 '&mut g': &'? mut |usize| yields i64 -> &'static str
245..246 'g': |usize| yields i64 -> &str 245..246 'g': |usize| yields i64 -> &'static str
255..261 '0usize': usize 255..261 '0usize': usize
273..299 'Corout...ded(y)': CoroutineState<i64, &str> 273..299 'Corout...ded(y)': CoroutineState<i64, &'static str>
297..298 'y': i64 297..298 'y': i64
303..312 '{ f(y); }': () 303..312 '{ f(y); }': ()
305..306 'f': fn f(i64) 305..306 'f': fn f(i64)
305..309 'f(y)': () 305..309 'f(y)': ()
307..308 'y': i64 307..308 'y': i64
321..348 'Corout...ete(r)': CoroutineState<i64, &str> 321..348 'Corout...ete(r)': CoroutineState<i64, &'static str>
346..347 'r': &str 346..347 'r': &'static str
352..354 '{}': () 352..354 '{}': ()
"#]], "#]],
); );
@ -2050,7 +2050,7 @@ fn f(x: (&&&&i32, &&&i32)) {
_ => loop {}, _ => loop {},
}; };
f; f;
//^ (&&&&i32, &&&i32) //^ (&'? &'? &'? &'? i32, &'? &'? &'? i32)
} }
"#, "#,
); );
@ -2059,10 +2059,10 @@ fn f(x: (&&&&i32, &&&i32)) {
fn f() { fn f() {
let x = &&&(&&&2, &&&&&3); let x = &&&(&&&2, &&&&&3);
let (y, z) = x; let (y, z) = x;
//^ &&&&i32 //^ &'? &'? &'? &'? i32
let t @ (y, z) = x; let t @ (y, z) = x;
t; t;
//^ &&&(&&&i32, &&&&&i32) //^ &'? &'? &'? (&'? &'? &'? i32, &'? &'? &'? &'? &'? i32)
} }
"#, "#,
); );
@ -2071,10 +2071,10 @@ fn f() {
fn f() { fn f() {
let x = &&&(&&&2, &&&&&3); let x = &&&(&&&2, &&&&&3);
let (y, z) = x; let (y, z) = x;
//^ &&&&i32 //^ &'? &'? &'? &'? i32
let t @ (y, z) = x; let t @ (y, z) = x;
t; t;
//^ &&&(&&&i32, &&&&&i32) //^ &'? &'? &'? (&'? &'? &'? i32, &'? &'? &'? &'? &'? i32)
} }
"#, "#,
); );
@ -2761,23 +2761,23 @@ impl S {
fn f() { fn f() {
let x = S; let x = S;
let c1 = || x.read(); let c1 = || x.read();
//^^ impl Fn() -> &S //^^ impl Fn() -> &'? S
let c2 = || x.write(); let c2 = || x.write();
//^^ impl FnMut() -> &mut S //^^ impl FnMut() -> &'? mut S
let c3 = || x.consume(); let c3 = || x.consume();
//^^ impl FnOnce() -> S //^^ impl FnOnce() -> S
let c3 = || x.consume().consume().consume(); let c3 = || x.consume().consume().consume();
//^^ impl FnOnce() -> S //^^ impl FnOnce() -> S
let c3 = || x.consume().write().read(); let c3 = || x.consume().write().read();
//^^ impl FnOnce() -> &S //^^ impl FnOnce() -> &'? S
let x = &mut x; let x = &mut x;
let c1 = || x.write(); let c1 = || x.write();
//^^ impl FnMut() -> &mut S //^^ impl FnMut() -> &'? mut S
let x = S; let x = S;
let c1 = || { let ref t = x; t }; let c1 = || { let ref t = x; t };
//^^ impl Fn() -> &S //^^ impl Fn() -> &'? S
let c2 = || { let ref mut t = x; t }; let c2 = || { let ref mut t = x; t };
//^^ impl FnMut() -> &mut S //^^ impl FnMut() -> &'? mut S
let c3 = || { let t = x; t }; let c3 = || { let t = x; t };
//^^ impl FnOnce() -> S //^^ impl FnOnce() -> S
} }
@ -3074,11 +3074,11 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
104..108 'self': &Box<T> 104..108 'self': &'? Box<T>
188..192 'self': &Box<Foo<T>> 188..192 'self': &'a Box<Foo<T>>
218..220 '{}': &T 218..220 '{}': &'a T
242..246 'self': &Box<Foo<T>> 242..246 'self': &'a Box<Foo<T>>
275..277 '{}': &Foo<T> 275..277 '{}': &'a Foo<T>
297..301 'self': Box<Foo<T>> 297..301 'self': Box<Foo<T>>
322..324 '{}': Foo<T> 322..324 '{}': Foo<T>
338..559 '{ ...r(); }': () 338..559 '{ ...r(); }': ()
@ -3088,21 +3088,21 @@ fn main() {
360..363 'Foo': extern "rust-call" Foo<i32>(i32) -> Foo<i32> 360..363 'Foo': extern "rust-call" Foo<i32>(i32) -> Foo<i32>
360..370 'Foo(0_i32)': Foo<i32> 360..370 'Foo(0_i32)': Foo<i32>
364..369 '0_i32': i32 364..369 '0_i32': i32
382..386 'bad1': &i32 382..386 'bad1': &'? i32
389..394 'boxed': Box<Foo<i32>> 389..394 'boxed': Box<Foo<i32>>
389..406 'boxed....nner()': &i32 389..406 'boxed....nner()': &'? i32
416..421 'good1': &i32 416..421 'good1': &'? i32
424..438 'Foo::get_inner': fn get_inner<i32, '{error}>(&Box<Foo<i32>>) -> &i32 424..438 'Foo::get_inner': fn get_inner<i32, '?>(&'? Box<Foo<i32>>) -> &'? i32
424..446 'Foo::g...boxed)': &i32 424..446 'Foo::g...boxed)': &'? i32
439..445 '&boxed': &Box<Foo<i32>> 439..445 '&boxed': &'? Box<Foo<i32>>
440..445 'boxed': Box<Foo<i32>> 440..445 'boxed': Box<Foo<i32>>
457..461 'bad2': &Foo<i32> 457..461 'bad2': &'? Foo<i32>
464..469 'boxed': Box<Foo<i32>> 464..469 'boxed': Box<Foo<i32>>
464..480 'boxed....self()': &Foo<i32> 464..480 'boxed....self()': &'? Foo<i32>
490..495 'good2': &Foo<i32> 490..495 'good2': &'? Foo<i32>
498..511 'Foo::get_self': fn get_self<i32, '{error}>(&Box<Foo<i32>>) -> &Foo<i32> 498..511 'Foo::get_self': fn get_self<i32, '?>(&'? Box<Foo<i32>>) -> &'? Foo<i32>
498..519 'Foo::g...boxed)': &Foo<i32> 498..519 'Foo::g...boxed)': &'? Foo<i32>
512..518 '&boxed': &Box<Foo<i32>> 512..518 '&boxed': &'? Box<Foo<i32>>
513..518 'boxed': Box<Foo<i32>> 513..518 'boxed': Box<Foo<i32>>
530..535 'inner': Foo<i32> 530..535 'inner': Foo<i32>
538..543 'boxed': Box<Foo<i32>> 538..543 'boxed': Box<Foo<i32>>
@ -3414,31 +3414,31 @@ struct TS(usize);
fn main() { fn main() {
let x; let x;
[x,] = &[1,]; [x,] = &[1,];
//^^^^expected &[i32; 1], got [{unknown}; _] //^^^^expected &'? [i32; 1], got [{unknown}; _]
let x; let x;
[(x,),] = &[(1,),]; [(x,),] = &[(1,),];
//^^^^^^^expected &[(i32,); 1], got [{unknown}; _] //^^^^^^^expected &'? [(i32,); 1], got [{unknown}; _]
let x; let x;
((x,),) = &((1,),); ((x,),) = &((1,),);
//^^^^^^^expected &((i32,),), got (({unknown},),) //^^^^^^^expected &'? ((i32,),), got (({unknown},),)
let x; let x;
(x,) = &(1,); (x,) = &(1,);
//^^^^expected &(i32,), got ({unknown},) //^^^^expected &'? (i32,), got ({unknown},)
let x; let x;
(S { a: x },) = &(S { a: 42 },); (S { a: x },) = &(S { a: 42 },);
//^^^^^^^^^^^^^expected &(S,), got (S,) //^^^^^^^^^^^^^expected &'? (S,), got (S,)
let x; let x;
S { a: x } = &S { a: 42 }; S { a: x } = &S { a: 42 };
//^^^^^^^^^^expected &S, got S //^^^^^^^^^^expected &'? S, got S
let x; let x;
TS(x) = &TS(42); TS(x) = &TS(42);
//^^^^^expected &TS, got TS //^^^^^expected &'? TS, got TS
} }
"#, "#,
); );
@ -3548,17 +3548,17 @@ fn f<T>(t: Ark<T>) {
} }
"#, "#,
expect![[r#" expect![[r#"
47..51 'self': &Ark<T> 47..51 'self': &'? Ark<T>
65..88 '{ ... }': *const T 65..88 '{ ... }': *const T
75..82 '&self.0': &T 75..82 '&self.0': &'? T
76..80 'self': &Ark<T> 76..80 'self': &'? Ark<T>
76..82 'self.0': T 76..82 'self.0': T
99..100 't': Ark<T> 99..100 't': Ark<T>
110..144 '{ ... (); }': () 110..144 '{ ... (); }': ()
116..124 'Ark::foo': fn foo<T>(&Ark<T>) -> *const T 116..124 'Ark::foo': fn foo<T>(&'? Ark<T>) -> *const T
116..128 'Ark::foo(&t)': *const T 116..128 'Ark::foo(&t)': *const T
116..141 'Ark::f...nst ()': *const () 116..141 'Ark::f...nst ()': *const ()
125..127 '&t': &Ark<T> 125..127 '&t': &'? Ark<T>
126..127 't': Ark<T> 126..127 't': Ark<T>
"#]], "#]],
); );
@ -3632,7 +3632,7 @@ pub struct CStr;
fn main() { fn main() {
c"ello"; c"ello";
//^^^^^^^ &CStr //^^^^^^^ &'static CStr
} }
"#, "#,
); );
@ -3659,7 +3659,7 @@ fn main() {
let are = "are"; let are = "are";
let count = 10; let count = 10;
builtin#format_args("hello {count:02} {} friends, we {are:?} {0}{last}", "fancy", last = "!"); builtin#format_args("hello {count:02} {} friends, we {are:?} {0}{last}", "fancy", last = "!");
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type: Arguments<'{error}> // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type: Arguments<'?>
} }
"#, "#,
); );

226
crates/hir-ty/src/tests/traits.rs
View file

@ -245,7 +245,7 @@ fn test() {
v.push("foo"); v.push("foo");
for x in v { for x in v {
x; x;
} //^ &str } //^ &'static str
} }
//- /alloc.rs crate:alloc //- /alloc.rs crate:alloc
@ -575,7 +575,7 @@ fn indexing_arrays() {
"fn main() { &mut [9][2]; }", "fn main() { &mut [9][2]; }",
expect![[r#" expect![[r#"
10..26 '{ &mut...[2]; }': () 10..26 '{ &mut...[2]; }': ()
12..23 '&mut [9][2]': &mut {unknown} 12..23 '&mut [9][2]': &'? mut {unknown}
17..20 '[9]': [i32; 1] 17..20 '[9]': [i32; 1]
17..23 '[9][2]': {unknown} 17..23 '[9][2]': {unknown}
18..19 '9': i32 18..19 '9': i32
@ -873,7 +873,7 @@ impl<U, T: Trait<U>> O<T> {
fn test(o: O<S>) { fn test(o: O<S>) {
o.foo(); o.foo();
} //^^^^^^^ &str } //^^^^^^^ &'? str
"#, "#,
); );
} }
@ -1016,15 +1016,15 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
z.foo2(); z.foo2();
}"#, }"#,
expect![[r#" expect![[r#"
29..33 'self': &Self 29..33 'self': &'? Self
54..58 'self': &Self 54..58 'self': &'? Self
77..78 'x': impl Trait<u16> 77..78 'x': impl Trait<u16>
97..99 '{}': () 97..99 '{}': ()
154..155 'x': impl Trait<u64> 154..155 'x': impl Trait<u64>
174..175 'y': &impl Trait<u32> 174..175 'y': &'? impl Trait<u32>
195..323 '{ ...2(); }': () 195..323 '{ ...2(); }': ()
201..202 'x': impl Trait<u64> 201..202 'x': impl Trait<u64>
208..209 'y': &impl Trait<u32> 208..209 'y': &'? impl Trait<u32>
219..220 'z': S<u16> 219..220 'z': S<u16>
223..224 'S': extern "rust-call" S<u16>(u16) -> S<u16> 223..224 'S': extern "rust-call" S<u16>(u16) -> S<u16>
223..227 'S(1)': S<u16> 223..227 'S(1)': S<u16>
@ -1034,13 +1034,13 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
237..238 'z': S<u16> 237..238 'z': S<u16>
245..246 'x': impl Trait<u64> 245..246 'x': impl Trait<u64>
245..252 'x.foo()': u64 245..252 'x.foo()': u64
258..259 'y': &impl Trait<u32> 258..259 'y': &'? impl Trait<u32>
258..265 'y.foo()': u32 258..265 'y.foo()': u32
271..272 'z': S<u16> 271..272 'z': S<u16>
271..278 'z.foo()': u16 271..278 'z.foo()': u16
284..285 'x': impl Trait<u64> 284..285 'x': impl Trait<u64>
284..292 'x.foo2()': i64 284..292 'x.foo2()': i64
298..299 'y': &impl Trait<u32> 298..299 'y': &'? impl Trait<u32>
298..306 'y.foo2()': i64 298..306 'y.foo2()': i64
312..313 'z': S<u16> 312..313 'z': S<u16>
312..320 'z.foo2()': i64 312..320 'z.foo2()': i64
@ -1204,26 +1204,26 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
z.foo2(); z.foo2();
}"#, }"#,
expect![[r#" expect![[r#"
29..33 'self': &Self 29..33 'self': &'? Self
54..58 'self': &Self 54..58 'self': &'? Self
98..100 '{}': () 98..100 '{}': ()
110..111 'x': impl Trait<u64> 110..111 'x': impl Trait<u64>
130..131 'y': &impl Trait<u64> 130..131 'y': &'? impl Trait<u64>
151..268 '{ ...2(); }': () 151..268 '{ ...2(); }': ()
157..158 'x': impl Trait<u64> 157..158 'x': impl Trait<u64>
164..165 'y': &impl Trait<u64> 164..165 'y': &'? impl Trait<u64>
175..176 'z': impl Trait<u64> 175..176 'z': impl Trait<u64>
179..182 'bar': fn bar() -> impl Trait<u64> 179..182 'bar': fn bar() -> impl Trait<u64>
179..184 'bar()': impl Trait<u64> 179..184 'bar()': impl Trait<u64>
190..191 'x': impl Trait<u64> 190..191 'x': impl Trait<u64>
190..197 'x.foo()': u64 190..197 'x.foo()': u64
203..204 'y': &impl Trait<u64> 203..204 'y': &'? impl Trait<u64>
203..210 'y.foo()': u64 203..210 'y.foo()': u64
216..217 'z': impl Trait<u64> 216..217 'z': impl Trait<u64>
216..223 'z.foo()': u64 216..223 'z.foo()': u64
229..230 'x': impl Trait<u64> 229..230 'x': impl Trait<u64>
229..237 'x.foo2()': i64 229..237 'x.foo2()': i64
243..244 'y': &impl Trait<u64> 243..244 'y': &'? impl Trait<u64>
243..251 'y.foo2()': i64 243..251 'y.foo2()': i64
257..258 'z': impl Trait<u64> 257..258 'z': impl Trait<u64>
257..265 'z.foo2()': i64 257..265 'z.foo2()': i64
@ -1328,7 +1328,7 @@ fn test() {
a.foo(); a.foo();
}"#, }"#,
expect![[r#" expect![[r#"
29..33 'self': &Self 29..33 'self': &'? Self
71..82 '{ loop {} }': ! 71..82 '{ loop {} }': !
73..80 'loop {}': ! 73..80 'loop {}': !
78..80 '{}': () 78..80 '{}': ()
@ -1366,8 +1366,8 @@ fn test() {
d.foo(); d.foo();
}"#, }"#,
expect![[r#" expect![[r#"
49..53 'self': &mut Self 49..53 'self': &'? mut Self
101..105 'self': &Self 101..105 'self': &'? Self
184..195 '{ loop {} }': ({unknown}, {unknown}) 184..195 '{ loop {} }': ({unknown}, {unknown})
186..193 'loop {}': ! 186..193 'loop {}': !
191..193 '{}': () 191..193 '{}': ()
@ -1414,10 +1414,10 @@ fn foo<const C: u8, T>() -> (impl FnOnce(&str, T), impl Trait<u8>) {
} }
"#, "#,
expect![[r#" expect![[r#"
134..165 '{ ...(C)) }': (impl FnOnce(&str, T), Bar<u8>) 134..165 '{ ...(C)) }': (impl FnOnce(&'? str, T), Bar<u8>)
140..163 '(|inpu...ar(C))': (impl FnOnce(&str, T), Bar<u8>) 140..163 '(|inpu...ar(C))': (impl FnOnce(&'? str, T), Bar<u8>)
141..154 '|input, t| {}': impl FnOnce(&str, T) 141..154 '|input, t| {}': impl FnOnce(&'? str, T)
142..147 'input': &str 142..147 'input': &'? str
149..150 't': T 149..150 't': T
152..154 '{}': () 152..154 '{}': ()
156..159 'Bar': extern "rust-call" Bar<u8>(u8) -> Bar<u8> 156..159 'Bar': extern "rust-call" Bar<u8>(u8) -> Bar<u8>
@ -1466,26 +1466,26 @@ fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
z.foo2(); z.foo2();
}"#, }"#,
expect![[r#" expect![[r#"
29..33 'self': &Self 29..33 'self': &'? Self
54..58 'self': &Self 54..58 'self': &'? Self
97..99 '{}': dyn Trait<u64> 97..99 '{}': dyn Trait<u64>
109..110 'x': dyn Trait<u64> 109..110 'x': dyn Trait<u64>
128..129 'y': &dyn Trait<u64> 128..129 'y': &'? dyn Trait<u64>
148..265 '{ ...2(); }': () 148..265 '{ ...2(); }': ()
154..155 'x': dyn Trait<u64> 154..155 'x': dyn Trait<u64>
161..162 'y': &dyn Trait<u64> 161..162 'y': &'? dyn Trait<u64>
172..173 'z': dyn Trait<u64> 172..173 'z': dyn Trait<u64>
176..179 'bar': fn bar() -> dyn Trait<u64> 176..179 'bar': fn bar() -> dyn Trait<u64>
176..181 'bar()': dyn Trait<u64> 176..181 'bar()': dyn Trait<u64>
187..188 'x': dyn Trait<u64> 187..188 'x': dyn Trait<u64>
187..194 'x.foo()': u64 187..194 'x.foo()': u64
200..201 'y': &dyn Trait<u64> 200..201 'y': &'? dyn Trait<u64>
200..207 'y.foo()': u64 200..207 'y.foo()': u64
213..214 'z': dyn Trait<u64> 213..214 'z': dyn Trait<u64>
213..220 'z.foo()': u64 213..220 'z.foo()': u64
226..227 'x': dyn Trait<u64> 226..227 'x': dyn Trait<u64>
226..234 'x.foo2()': i64 226..234 'x.foo2()': i64
240..241 'y': &dyn Trait<u64> 240..241 'y': &'? dyn Trait<u64>
240..248 'y.foo2()': i64 240..248 'y.foo2()': i64
254..255 'z': dyn Trait<u64> 254..255 'z': dyn Trait<u64>
254..262 'z.foo2()': i64 254..262 'z.foo2()': i64
@ -1514,16 +1514,16 @@ fn test(s: S<u32, i32>) {
s.bar().baz(); s.bar().baz();
}"#, }"#,
expect![[r#" expect![[r#"
32..36 'self': &Self 32..36 'self': &'? Self
102..106 'self': &S<T, U> 102..106 'self': &'? S<T, U>
128..139 '{ loop {} }': &dyn Trait<T, U> 128..139 '{ loop {} }': &'? dyn Trait<T, U>
130..137 'loop {}': ! 130..137 'loop {}': !
135..137 '{}': () 135..137 '{}': ()
175..179 'self': &Self 175..179 'self': &'? Self
251..252 's': S<u32, i32> 251..252 's': S<u32, i32>
267..289 '{ ...z(); }': () 267..289 '{ ...z(); }': ()
273..274 's': S<u32, i32> 273..274 's': S<u32, i32>
273..280 's.bar()': &dyn Trait<u32, i32> 273..280 's.bar()': &'? dyn Trait<u32, i32>
273..286 's.bar().baz()': (u32, i32) 273..286 's.bar().baz()': (u32, i32)
"#]], "#]],
); );
@ -1548,19 +1548,19 @@ fn test(x: Trait, y: &Trait) -> u64 {
z.foo(); z.foo();
}"#, }"#,
expect![[r#" expect![[r#"
26..30 'self': &Self 26..30 'self': &'? Self
60..62 '{}': dyn Trait 60..62 '{}': dyn Trait
72..73 'x': dyn Trait 72..73 'x': dyn Trait
82..83 'y': &dyn Trait 82..83 'y': &'? dyn Trait
100..175 '{ ...o(); }': u64 100..175 '{ ...o(); }': u64
106..107 'x': dyn Trait 106..107 'x': dyn Trait
113..114 'y': &dyn Trait 113..114 'y': &'? dyn Trait
124..125 'z': dyn Trait 124..125 'z': dyn Trait
128..131 'bar': fn bar() -> dyn Trait 128..131 'bar': fn bar() -> dyn Trait
128..133 'bar()': dyn Trait 128..133 'bar()': dyn Trait
139..140 'x': dyn Trait 139..140 'x': dyn Trait
139..146 'x.foo()': u64 139..146 'x.foo()': u64
152..153 'y': &dyn Trait 152..153 'y': &'? dyn Trait
152..159 'y.foo()': u64 152..159 'y.foo()': u64
165..166 'z': dyn Trait 165..166 'z': dyn Trait
165..172 'z.foo()': u64 165..172 'z.foo()': u64
@ -1580,14 +1580,14 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
31..35 'self': &S 31..35 'self': &'? S
37..39 '{}': () 37..39 '{}': ()
47..48 '_': &dyn Fn(S) 47..48 '_': &'? dyn Fn(S)
58..60 '{}': () 58..60 '{}': ()
71..105 '{ ...()); }': () 71..105 '{ ...()); }': ()
77..78 'f': fn f(&dyn Fn(S)) 77..78 'f': fn f(&'? dyn Fn(S))
77..102 'f(&|nu...foo())': () 77..102 'f(&|nu...foo())': ()
79..101 '&|numb....foo()': &impl Fn(S) 79..101 '&|numb....foo()': &'? impl Fn(S)
80..101 '|numbe....foo()': impl Fn(S) 80..101 '|numbe....foo()': impl Fn(S)
81..87 'number': S 81..87 'number': S
89..95 'number': S 89..95 'number': S
@ -1790,7 +1790,7 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
y.foo(); y.foo();
}"#, }"#,
expect![[r#" expect![[r#"
53..57 'self': &Self 53..57 'self': &'? Self
66..68 '{}': u32 66..68 '{}': u32
185..186 'x': T 185..186 'x': T
191..192 'y': U 191..192 'y': U
@ -1819,11 +1819,11 @@ fn test(x: &impl Trait1) {
x.foo(); x.foo();
}"#, }"#,
expect![[r#" expect![[r#"
53..57 'self': &Self 53..57 'self': &'? Self
66..68 '{}': u32 66..68 '{}': u32
119..120 'x': &impl Trait1 119..120 'x': &'? impl Trait1
136..152 '{ ...o(); }': () 136..152 '{ ...o(); }': ()
142..143 'x': &impl Trait1 142..143 'x': &'? impl Trait1
142..149 'x.foo()': u32 142..149 'x.foo()': u32
"#]], "#]],
); );
@ -1934,8 +1934,8 @@ fn test() {
opt.map(f); opt.map(f);
}"#, }"#,
expect![[r#" expect![[r#"
28..32 'self': &Self 28..32 'self': &'? Self
132..136 'self': &Bar<F> 132..136 'self': &'? Bar<F>
149..160 '{ loop {} }': (A1, R) 149..160 '{ loop {} }': (A1, R)
151..158 'loop {}': ! 151..158 'loop {}': !
156..158 '{}': () 156..158 '{}': ()
@ -1988,7 +1988,7 @@ fn test() {
let r2 = lazy2.foo(); let r2 = lazy2.foo();
}"#, }"#,
expect![[r#" expect![[r#"
36..40 'self': &Foo 36..40 'self': &'? Foo
51..53 '{}': usize 51..53 '{}': usize
131..132 'f': F 131..132 'f': F
151..153 '{}': Lazy<T, F> 151..153 '{}': Lazy<T, F>
@ -2262,14 +2262,14 @@ impl Trait for S2 {
fn f(&self, x: <Self>::Item) { let y = x; } fn f(&self, x: <Self>::Item) { let y = x; }
}"#, }"#,
expect![[r#" expect![[r#"
40..44 'self': &Self 40..44 'self': &'? Self
46..47 'x': Trait::Item<Self> 46..47 'x': Trait::Item<Self>
126..130 'self': &S 126..130 'self': &'? S
132..133 'x': u32 132..133 'x': u32
147..161 '{ let y = x; }': () 147..161 '{ let y = x; }': ()
153..154 'y': u32 153..154 'y': u32
157..158 'x': u32 157..158 'x': u32
228..232 'self': &S2 228..232 'self': &'? S2
234..235 'x': i32 234..235 'x': i32
251..265 '{ let y = x; }': () 251..265 '{ let y = x; }': ()
257..258 'y': i32 257..258 'y': i32
@ -2643,12 +2643,12 @@ fn main() {
72..74 '_v': F 72..74 '_v': F
117..120 '{ }': () 117..120 '{ }': ()
132..163 '{ ... }); }': () 132..163 '{ ... }); }': ()
138..148 'f::<(), _>': fn f<(), impl FnOnce(&())>(impl FnOnce(&())) 138..148 'f::<(), _>': fn f<(), impl FnOnce(&'? ())>(impl FnOnce(&'? ()))
138..160 'f::<()... z; })': () 138..160 'f::<()... z; })': ()
149..159 '|z| { z; }': impl FnOnce(&()) 149..159 '|z| { z; }': impl FnOnce(&'? ())
150..151 'z': &() 150..151 'z': &'? ()
153..159 '{ z; }': () 153..159 '{ z; }': ()
155..156 'z': &() 155..156 'z': &'? ()
"#]], "#]],
); );
} }
@ -2897,13 +2897,13 @@ fn test(x: &dyn Foo) {
foo(x); foo(x);
}"#, }"#,
expect![[r#" expect![[r#"
21..22 'x': &dyn Foo 21..22 'x': &'? dyn Foo
34..36 '{}': () 34..36 '{}': ()
46..47 'x': &dyn Foo 46..47 'x': &'? dyn Foo
59..74 '{ foo(x); }': () 59..74 '{ foo(x); }': ()
65..68 'foo': fn foo(&dyn Foo) 65..68 'foo': fn foo(&'? dyn Foo)
65..71 'foo(x)': () 65..71 'foo(x)': ()
69..70 'x': &dyn Foo 69..70 'x': &'? dyn Foo
"#]], "#]],
); );
} }
@ -2927,7 +2927,7 @@ fn test() {
(IsCopy, NotCopy).test(); (IsCopy, NotCopy).test();
}"#, }"#,
expect![[r#" expect![[r#"
78..82 'self': &Self 78..82 'self': &'? Self
134..235 '{ ...t(); }': () 134..235 '{ ...t(); }': ()
140..146 'IsCopy': IsCopy 140..146 'IsCopy': IsCopy
140..153 'IsCopy.test()': bool 140..153 'IsCopy.test()': bool
@ -2969,7 +2969,7 @@ fn test() {
28..29 'T': {unknown} 28..29 'T': {unknown}
36..38 '{}': T 36..38 '{}': T
36..38: expected T, got () 36..38: expected T, got ()
113..117 'self': &Self 113..117 'self': &'? Self
169..249 '{ ...t(); }': () 169..249 '{ ...t(); }': ()
175..178 'foo': fn foo() 175..178 'foo': fn foo()
175..185 'foo.test()': bool 175..185 'foo.test()': bool
@ -2997,16 +2997,16 @@ fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
f3.test(); f3.test();
}"#, }"#,
expect![[r#" expect![[r#"
22..26 'self': &Self 22..26 'self': &'? Self
76..78 'f1': fn() 76..78 'f1': fn()
86..88 'f2': fn(usize) -> u8 86..88 'f2': fn(usize) -> u8
107..109 'f3': fn(u8, u8) -> &u8 107..109 'f3': fn(u8, u8) -> &'? u8
130..178 '{ ...t(); }': () 130..178 '{ ...t(); }': ()
136..138 'f1': fn() 136..138 'f1': fn()
136..145 'f1.test()': bool 136..145 'f1.test()': bool
151..153 'f2': fn(usize) -> u8 151..153 'f2': fn(usize) -> u8
151..160 'f2.test()': bool 151..160 'f2.test()': bool
166..168 'f3': fn(u8, u8) -> &u8 166..168 'f3': fn(u8, u8) -> &'? u8
166..175 'f3.test()': bool 166..175 'f3.test()': bool
"#]], "#]],
); );
@ -3027,13 +3027,13 @@ fn test() {
(1u8, *"foo").test(); // not Sized (1u8, *"foo").test(); // not Sized
}"#, }"#,
expect![[r#" expect![[r#"
22..26 'self': &Self 22..26 'self': &'? Self
79..194 '{ ...ized }': () 79..194 '{ ...ized }': ()
85..88 '1u8': u8 85..88 '1u8': u8
85..95 '1u8.test()': bool 85..95 '1u8.test()': bool
101..116 '(*"foo").test()': {unknown} 101..116 '(*"foo").test()': {unknown}
102..108 '*"foo"': str 102..108 '*"foo"': str
103..108 '"foo"': &str 103..108 '"foo"': &'static str
135..145 '(1u8, 1u8)': (u8, u8) 135..145 '(1u8, 1u8)': (u8, u8)
135..152 '(1u8, ...test()': bool 135..152 '(1u8, ...test()': bool
136..139 '1u8': u8 136..139 '1u8': u8
@ -3042,7 +3042,7 @@ fn test() {
158..178 '(1u8, ...test()': {unknown} 158..178 '(1u8, ...test()': {unknown}
159..162 '1u8': u8 159..162 '1u8': u8
164..170 '*"foo"': str 164..170 '*"foo"': str
165..170 '"foo"': &str 165..170 '"foo"': &'static str
"#]], "#]],
); );
} }
@ -3093,7 +3093,7 @@ fn foo() {
93..94 'x': Option<i32> 93..94 'x': Option<i32>
109..111 '{}': () 109..111 '{}': ()
117..124 '(&f)(s)': () 117..124 '(&f)(s)': ()
118..120 '&f': &impl Fn(Option<i32>) 118..120 '&f': &'? impl Fn(Option<i32>)
119..120 'f': impl Fn(Option<i32>) 119..120 'f': impl Fn(Option<i32>)
122..123 's': Option<i32> 122..123 's': Option<i32>
"#]], "#]],
@ -3170,25 +3170,25 @@ fn foo() {
f(&s); f(&s);
}"#, }"#,
expect![[r#" expect![[r#"
154..158 'self': &Box<T> 154..158 'self': &'? Box<T>
166..205 '{ ... }': &T 166..205 '{ ... }': &'? T
176..199 'unsafe...nner }': &T 176..199 'unsafe...nner }': &'? T
185..197 '&*self.inner': &T 185..197 '&*self.inner': &'? T
186..197 '*self.inner': T 186..197 '*self.inner': T
187..191 'self': &Box<T> 187..191 'self': &'? Box<T>
187..197 'self.inner': *mut T 187..197 'self.inner': *mut T
218..324 '{ ...&s); }': () 218..324 '{ ...&s); }': ()
228..229 's': Option<i32> 228..229 's': Option<i32>
232..236 'None': Option<i32> 232..236 'None': Option<i32>
246..247 'f': Box<dyn FnOnce(&Option<i32>)> 246..247 'f': Box<dyn FnOnce(&'? Option<i32>)>
281..310 'Box { ... {}) }': Box<dyn FnOnce(&Option<i32>)> 281..310 'Box { ... {}) }': Box<dyn FnOnce(&'? Option<i32>)>
294..308 '&mut (|ps| {})': &mut impl FnOnce(&Option<i32>) 294..308 '&mut (|ps| {})': &'? mut impl FnOnce(&'? Option<i32>)
300..307 '|ps| {}': impl FnOnce(&Option<i32>) 300..307 '|ps| {}': impl FnOnce(&'? Option<i32>)
301..303 'ps': &Option<i32> 301..303 'ps': &'? Option<i32>
305..307 '{}': () 305..307 '{}': ()
316..317 'f': Box<dyn FnOnce(&Option<i32>)> 316..317 'f': Box<dyn FnOnce(&'? Option<i32>)>
316..321 'f(&s)': () 316..321 'f(&s)': ()
318..320 '&s': &Option<i32> 318..320 '&s': &'? Option<i32>
319..320 's': Option<i32> 319..320 's': Option<i32>
"#]], "#]],
); );
@ -3320,7 +3320,7 @@ fn f() {
} }
}"#, }"#,
expect![[r#" expect![[r#"
46..50 'self': &Self 46..50 'self': &'? Self
58..63 '{ 0 }': u8 58..63 '{ 0 }': u8
60..61 '0': u8 60..61 '0': u8
115..185 '{ ... } }': () 115..185 '{ ... } }': ()
@ -3595,7 +3595,7 @@ fn take_u32(_: u32) {}
fn minimized() { fn minimized() {
let v = V::default(); let v = V::default();
let p = v.get(&0); let p = v.get(&0);
//^ &u32 //^ &'? u32
take_u32(42 + p); take_u32(42 + p);
} }
"#, "#,
@ -3625,7 +3625,7 @@ fn take_u32(_: u32) {}
fn minimized() { fn minimized() {
let v = V::default(); let v = V::default();
let p = v.get(); let p = v.get();
//^ &{unknown} //^ &'? {unknown}
take_u32(42 + p); take_u32(42 + p);
} }
"#, "#,
@ -3684,11 +3684,11 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
44..48 'self': &Self 44..48 'self': &'? Self
133..137 'self': &[u8; 4] 133..137 'self': &'? [u8; 4]
155..172 '{ ... }': usize 155..172 '{ ... }': usize
165..166 '2': usize 165..166 '2': usize
236..240 'self': &[u8; 2] 236..240 'self': &'? [u8; 2]
258..275 '{ ... }': u8 258..275 '{ ... }': u8
268..269 '2': u8 268..269 '2': u8
289..392 '{ ...g(); }': () 289..392 '{ ...g(); }': ()
@ -3732,11 +3732,11 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
44..48 'self': &Self 44..48 'self': &'? Self
151..155 'self': &[u8; L] 151..155 'self': &'? [u8; L]
173..194 '{ ... }': [u8; L] 173..194 '{ ... }': [u8; L]
183..188 '*self': [u8; L] 183..188 '*self': [u8; L]
184..188 'self': &[u8; L] 184..188 'self': &'? [u8; L]
208..260 '{ ...g(); }': () 208..260 '{ ...g(); }': ()
218..219 'v': [u8; 2] 218..219 'v': [u8; 2]
222..230 '[0u8; 2]': [u8; 2] 222..230 '[0u8; 2]': [u8; 2]
@ -4056,13 +4056,13 @@ fn g(t: &(dyn Sync + T2 + T1 + Send)) {
} }
"#, "#,
expect![[r#" expect![[r#"
68..69 't': &{unknown} 68..69 't': &'? {unknown}
101..103 '{}': () 101..103 '{}': ()
109..110 't': &{unknown} 109..110 't': &'? {unknown}
142..155 '{ f(t); }': () 142..155 '{ f(t); }': ()
148..149 'f': fn f(&{unknown}) 148..149 'f': fn f(&'? {unknown})
148..152 'f(t)': () 148..152 'f(t)': ()
150..151 't': &{unknown} 150..151 't': &'? {unknown}
"#]], "#]],
); );
@ -4105,7 +4105,7 @@ trait Trait {
} }
fn f(t: &dyn Trait<T = (), T = ()>) {} fn f(t: &dyn Trait<T = (), T = ()>) {}
//^&{unknown} //^&'? {unknown}
"#, "#,
); );
} }
@ -4175,27 +4175,27 @@ trait Trait {
fn f<T>(v: impl Trait) { fn f<T>(v: impl Trait) {
let a = v.get::<i32>().deref(); let a = v.get::<i32>().deref();
//^ &i32 //^ &'? i32
let a = v.get::<T>().deref(); let a = v.get::<T>().deref();
//^ &T //^ &'? T
} }
fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) { fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) {
let a = v.get::<T>(); let a = v.get::<T>();
//^ &T //^ &'a T
let a = v.get::<()>(); let a = v.get::<()>();
//^ Trait::Assoc<(), impl Trait<Assoc<T> = &T>> //^ Trait::Assoc<(), impl Trait<Assoc<T> = &'a T>>
} }
fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) { fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {
let a = v.get::<i32>(); let a = v.get::<i32>();
//^ &i32 //^ &'a i32
let a = v.get::<i64>(); let a = v.get::<i64>();
//^ &i64 //^ &'a i64
} }
fn i<'a>(v: impl Trait<Assoc<i32> = &'a i32, Assoc<i64> = &'a i64>) { fn i<'a>(v: impl Trait<Assoc<i32> = &'a i32, Assoc<i64> = &'a i64>) {
let a = v.get::<i32>(); let a = v.get::<i32>();
//^ &i32 //^ &'a i32
let a = v.get::<i64>(); let a = v.get::<i64>();
//^ &i64 //^ &'a i64
} }
"#, "#,
); );
@ -4221,12 +4221,12 @@ fn f<'a>(v: &dyn Trait<Assoc<i32> = &'a i32>) {
} }
"#, "#,
expect![[r#" expect![[r#"
90..94 'self': &Self 90..94 'self': &'? Self
127..128 'v': &(dyn Trait<Assoc<i32> = &i32>) 127..128 'v': &'? (dyn Trait<Assoc<i32> = &'a i32>)
164..195 '{ ...f(); }': () 164..195 '{ ...f(); }': ()
170..171 'v': &(dyn Trait<Assoc<i32> = &i32>) 170..171 'v': &'? (dyn Trait<Assoc<i32> = &'a i32>)
170..184 'v.get::<i32>()': &i32 170..184 'v.get::<i32>()': &'? i32
170..192 'v.get:...eref()': &i32 170..192 'v.get:...eref()': &'? i32
"#]], "#]],
); );
} }
@ -4487,19 +4487,19 @@ fn derive_macro_bounds() {
let x = (&Copy).clone(); let x = (&Copy).clone();
//^ Copy //^ Copy
let x = (&NotCopy).clone(); let x = (&NotCopy).clone();
//^ &NotCopy //^ &'? NotCopy
let x = (&Generic(Copy)).clone(); let x = (&Generic(Copy)).clone();
//^ Generic<Copy> //^ Generic<Copy>
let x = (&Generic(NotCopy)).clone(); let x = (&Generic(NotCopy)).clone();
//^ &Generic<NotCopy> //^ &'? Generic<NotCopy>
let x: &AssocGeneric<Copy> = &AssocGeneric(NotCopy); let x: &AssocGeneric<Copy> = &AssocGeneric(NotCopy);
let x = x.clone(); let x = x.clone();
//^ &AssocGeneric<Copy> //^ &'? AssocGeneric<Copy>
// let x: &AssocGeneric2<Copy> = &AssocGeneric2(NotCopy); // let x: &AssocGeneric2<Copy> = &AssocGeneric2(NotCopy);
// let x = x.clone(); // let x = x.clone();
let x: &AssocGeneric3<Copy> = &AssocGeneric3(Generic(NotCopy)); let x: &AssocGeneric3<Copy> = &AssocGeneric3(Generic(NotCopy));
let x = x.clone(); let x = x.clone();
//^ &AssocGeneric3<Copy> //^ &'? AssocGeneric3<Copy>
let x = (&R1(Vec())).clone(); let x = (&R1(Vec())).clone();
//^ R1 //^ R1
let x = (&R2(R1(Vec()))).clone(); let x = (&R2(R1(Vec()))).clone();
@ -4582,7 +4582,7 @@ impl B for u16 {
fn ttt() { fn ttt() {
let inp = Y; let inp = Y;
x::<u16>(&inp); x::<u16>(&inp);
//^^^^ expected &X, got &Y //^^^^ expected &'? X, got &'? Y
} }
"#, "#,
); );
@ -4629,7 +4629,7 @@ fn foo() {
let mut map = SomeMap; let mut map = SomeMap;
map["a"] = (); map["a"] = ();
map; map;
//^^^ SomeMap<&str> //^^^ SomeMap<&'static str>
} }
"#, "#,
); );

2
crates/ide-assists/src/handlers/extract_function.rs
View file

@ -5623,7 +5623,7 @@ fn func<T: Debug>(i: Struct<'_, T>) {
fun_name(i); fun_name(i);
} }
fn $0fun_name(i: Struct<'_, T>) { fn $0fun_name(i: Struct<T>) {
foo(i); foo(i);
} }
"#, "#,

4
crates/ide-completion/src/tests/predicate.rs
View file

@ -19,7 +19,7 @@ struct Foo<'lt, T, const C: usize> where $0 {}
en Enum Enum en Enum Enum
ma makro!(…) macro_rules! makro ma makro!(…) macro_rules! makro
md module md module
st Foo<…> Foo<'{error}, {unknown}, _> st Foo<…> Foo<{unknown}, _>
st Record Record st Record Record
st Tuple Tuple st Tuple Tuple
st Unit Unit st Unit Unit
@ -92,7 +92,7 @@ struct Foo<'lt, T, const C: usize> where for<'a> $0 {}
en Enum Enum en Enum Enum
ma makro!(…) macro_rules! makro ma makro!(…) macro_rules! makro
md module md module
st Foo<…> Foo<'{error}, {unknown}, _> st Foo<…> Foo<{unknown}, _>
st Record Record st Record Record
st Tuple Tuple st Tuple Tuple
st Unit Unit st Unit Unit

8
crates/ide-completion/src/tests/type_pos.rs
View file

@ -20,8 +20,8 @@ struct Foo<'lt, T, const C: usize> {
en Enum Enum en Enum Enum
ma makro!(…) macro_rules! makro ma makro!(…) macro_rules! makro
md module md module
sp Self Foo<'{error}, {unknown}, _> sp Self Foo<{unknown}, _>
st Foo<…> Foo<'{error}, {unknown}, _> st Foo<…> Foo<{unknown}, _>
st Record Record st Record Record
st Tuple Tuple st Tuple Tuple
st Unit Unit st Unit Unit
@ -45,8 +45,8 @@ struct Foo<'lt, T, const C: usize>(f$0);
en Enum Enum en Enum Enum
ma makro!(…) macro_rules! makro ma makro!(…) macro_rules! makro
md module md module
sp Self Foo<'{error}, {unknown}, _> sp Self Foo<{unknown}, _>
st Foo<…> Foo<'{error}, {unknown}, _> st Foo<…> Foo<{unknown}, _>
st Record Record st Record Record
st Tuple Tuple st Tuple Tuple
st Unit Unit st Unit Unit

21
crates/ide/src/inlay_hints/bind_pat.rs
View file

@ -331,6 +331,25 @@ fn main(a: SliceIter<'_, Container>) {
); );
} }
#[test]
fn lt_hints() {
check_types(
r#"
struct S<'lt>;
fn f<'a>() {
let x = S::<'static>;
//^ S<'static>
let y = S::<'_>;
//^ S
let z = S::<'a>;
//^ S<'a>
}
"#,
);
}
#[test] #[test]
fn fn_hints() { fn fn_hints() {
check_types( check_types(
@ -341,7 +360,7 @@ fn foo1() -> impl Fn(f64) { loop {} }
fn foo2() -> impl Fn(f64, f64) { loop {} } fn foo2() -> impl Fn(f64, f64) { loop {} }
fn foo3() -> impl Fn(f64, f64) -> u32 { loop {} } fn foo3() -> impl Fn(f64, f64) -> u32 { loop {} }
fn foo4() -> &'static dyn Fn(f64, f64) -> u32 { loop {} } fn foo4() -> &'static dyn Fn(f64, f64) -> u32 { loop {} }
fn foo5() -> &'static dyn Fn(&'static dyn Fn(f64, f64) -> u32, f64) -> u32 { loop {} } fn foo5() -> &'static for<'a> dyn Fn(&'a dyn Fn(f64, f64) -> u32, f64) -> u32 { loop {} }
fn foo6() -> impl Fn(f64, f64) -> u32 + Sized { loop {} } fn foo6() -> impl Fn(f64, f64) -> u32 + Sized { loop {} }
fn foo7() -> *const (impl Fn(f64, f64) -> u32 + Sized) { loop {} } fn foo7() -> *const (impl Fn(f64, f64) -> u32 + Sized) { loop {} }