From 4789a993eb26963a2411dcc3041733a3b034634a Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Tue, 28 Jan 2020 21:42:58 +0100
Subject: Fix printing of function types

---
 crates/ra_hir_ty/src/tests/coercion.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'crates/ra_hir_ty/src/tests/coercion.rs')

diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 76a1b46c0..fc5ef36a5 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -75,7 +75,7 @@ fn test2() {
     [124; 131) 'loop {}': !
     [129; 131) '{}': ()
     [160; 173) '{     gen() }': *mut [U]
-    [166; 169) 'gen': fn gen<U>() -> *mut [T; _]
+    [166; 169) 'gen': fn gen<U>() -> *mut [U; _]
     [166; 171) 'gen()': *mut [U; _]
     [186; 420) '{     ...rr); }': ()
     [196; 199) 'arr': &[u8; _]
@@ -85,14 +85,14 @@ fn test2() {
     [227; 228) 'a': &[u8]
     [237; 240) 'arr': &[u8; _]
     [250; 251) 'b': u8
-    [254; 255) 'f': fn f<u8>(&[T]) -> T
+    [254; 255) 'f': fn f<u8>(&[u8]) -> u8
     [254; 260) 'f(arr)': u8
     [256; 259) 'arr': &[u8; _]
     [270; 271) 'c': &[u8]
     [280; 287) '{ arr }': &[u8]
     [282; 285) 'arr': &[u8; _]
     [297; 298) 'd': u8
-    [301; 302) 'g': fn g<u8>(S<&[T]>) -> T
+    [301; 302) 'g': fn g<u8>(S<&[u8]>) -> u8
     [301; 316) 'g(S { a: arr })': u8
     [303; 315) 'S { a: arr }': S<&[u8]>
     [310; 313) 'arr': &[u8; _]
@@ -164,15 +164,15 @@ fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
     [400; 401) 'c': C<[u8; _]>
     [415; 481) '{     ...(c); }': ()
     [425; 426) 'd': A<[{unknown}]>
-    [429; 433) 'foo1': fn foo1<{unknown}>(A<[T]>) -> A<[T]>
+    [429; 433) 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
     [429; 436) 'foo1(a)': A<[{unknown}]>
     [434; 435) 'a': A<[u8; _]>
     [446; 447) 'e': B<[u8]>
-    [450; 454) 'foo2': fn foo2<u8>(B<[T]>) -> B<[T]>
+    [450; 454) 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
     [450; 457) 'foo2(b)': B<[u8]>
     [455; 456) 'b': B<[u8; _]>
     [467; 468) 'f': C<[u8]>
-    [471; 475) 'foo3': fn foo3<u8>(C<[T]>) -> C<[T]>
+    [471; 475) 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
     [471; 478) 'foo3(c)': C<[u8]>
     [476; 477) 'c': C<[u8; _]>
     "###
@@ -202,7 +202,7 @@ fn test() {
     [64; 123) 'if tru...     }': &[i32]
     [67; 71) 'true': bool
     [72; 97) '{     ...     }': &[i32]
-    [82; 85) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [82; 85) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [82; 91) 'foo(&[1])': &[i32]
     [86; 90) '&[1]': &[i32; _]
     [87; 90) '[1]': [i32; _]
@@ -242,7 +242,7 @@ fn test() {
     [83; 86) '[1]': [i32; _]
     [84; 85) '1': i32
     [98; 123) '{     ...     }': &[i32]
-    [108; 111) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [108; 111) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [108; 117) 'foo(&[1])': &[i32]
     [112; 116) '&[1]': &[i32; _]
     [113; 116) '[1]': [i32; _]
@@ -275,7 +275,7 @@ fn test(i: i32) {
     [70; 147) 'match ...     }': &[i32]
     [76; 77) 'i': i32
     [88; 89) '2': i32
-    [93; 96) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [93; 102) 'foo(&[2])': &[i32]
     [97; 101) '&[2]': &[i32; _]
     [98; 101) '[2]': [i32; _]
@@ -320,7 +320,7 @@ fn test(i: i32) {
     [94; 97) '[1]': [i32; _]
     [95; 96) '1': i32
     [107; 108) '2': i32
-    [112; 115) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [112; 121) 'foo(&[2])': &[i32]
     [116; 120) '&[2]': &[i32; _]
     [117; 120) '[2]': [i32; _]
@@ -438,16 +438,16 @@ fn test() {
     [43; 45) '*x': T
     [44; 45) 'x': &T
     [58; 127) '{     ...oo); }': ()
-    [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T
+    [64; 73) 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
     [64; 79) 'takes_ref(&Foo)': Foo
     [74; 78) '&Foo': &Foo
     [75; 78) 'Foo': Foo
-    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T
+    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
     [85; 101) 'takes_...&&Foo)': &Foo
     [95; 100) '&&Foo': &&Foo
     [96; 100) '&Foo': &Foo
     [97; 100) 'Foo': Foo
-    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T
+    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
     [107; 124) 'takes_...&&Foo)': &&Foo
     [117; 123) '&&&Foo': &&&Foo
     [118; 123) '&&Foo': &&Foo
-- 
cgit v1.2.3