add tests

Author: b-naber

src/test/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr

@@ -4,6 +4,8 @@ error[E0277]: the trait bound `(): Add<A>` is not satisfied
 LL |     r = r + a;
    |           ^ the trait `Add<A>` is not implemented for `()`
 
-error: aborting due to previous error
+error: requires `copy` lang_item
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

src/test/ui/coercion/type-ascription/coerce-array-repeat-in-fn-arg.rs

@@ -0,0 +1,10 @@
+#![feature(type_ascription)]
+
+// build-pass
+
+fn foo(_arg : [&[u32];3]) {}
+
+fn main() {
+  let arr = [4,5,6];
+  foo([&arr : &[u32]; 3]);
+}

src/test/ui/coercion/type-ascription/coerce-enum-variant.rs

@@ -0,0 +1,13 @@
+// build-pass
+
+#![feature(type_ascription)]
+
+enum Foo<'a> {
+  A((u32, &'a [u32])),
+  B((u32, &'a [u32; 4])),
+}
+
+fn main() {
+  let arr = [4,5,6];
+  let temp = Foo::A((10, &arr : &[u32]));
+}

src/test/ui/coercion/type-ascription/coerce-nested-tuple-in-let-stmt.rs

@@ -0,0 +1,16 @@
+// run-pass
+
+#![feature(type_ascription)]
+
+use std::any::type_name;
+use std::assert_eq;
+
+fn type_of<T>(_: T) -> &'static str {
+    type_name::<T>()
+}
+
+fn main() {
+  let arr = [5,6,7];
+  let tup = (5, (3, (12, &arr : &[u32])), &arr : &[u32]);
+  assert_eq!(type_of(tup), "(i32, (i32, (i32, &[u32])), &[u32])");
+}

src/test/ui/coercion/type-ascription/coerce-return-expr.rs

@@ -0,0 +1,12 @@
+#![feature(type_ascription)]
+
+fn foo<'a>(arg : (u32, (u32, &'a [u32; 3]))) -> (u32, (u32, &'a [u32])) {
+  arg : (u32, (u32, &[u32]))
+    //~^ ERROR: mismatched types
+}
+
+fn main() {
+  let arr = [4,5,6];
+  let tup = (3, (9, &arr));
+  let result = foo(tup);
+}

src/test/ui/coercion/type-ascription/coerce-return-expr.stderr

@@ -0,0 +1,12 @@
+error[E0308]: mismatched types
+  --> $DIR/coerce-return-expr.rs:4:3
+   |
+LL |   arg : (u32, (u32, &[u32]))
+   |   ^^^ expected slice `[u32]`, found array `[u32; 3]`
+   |
+   = note: expected tuple `(_, (_, &[u32]))`
+              found tuple `(_, (_, &'a [u32; 3]))`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/coercion/type-ascription/coerce-struct-fields-pass-in-let-stmt.rs

@@ -0,0 +1,29 @@
+// Here we test for coercions in struct fields of nested type ascriptions
+// inside a tuple using an unsized coercion and a coercion from &mut -> &
+
+// run-pass
+
+#![feature(type_ascription)]
+
+use std::any::type_name;
+use std::assert_eq;
+
+fn type_of<T>(_: T) -> &'static str {
+    type_name::<T>()
+}
+
+struct Foo<'a, 'b, T1, T2> {
+  _a : (T1, (T1, &'a [T1]), &'b T2),
+}
+
+struct Bar {
+  _b : u32,
+}
+
+fn main() {
+  let mut bar = Bar {_b : 26};
+  let arr = [4,5,6];
+  let tup = (9, (3, &arr : &[u32]), &mut bar);
+  assert_eq!(type_of(tup), "(i32, (i32, &[u32]), &mut coerce_struct_fields_pass_in_let_stmt::Bar)");
+  let _ = Foo { _a : (9, (3, &arr : &[u32]), &mut bar) };
+}

src/test/ui/coercion/type-ascription/coerce-to-unsized-in-return-expr.rs

@@ -0,0 +1,12 @@
+// build-pass
+
+#![feature(type_ascription)]
+
+fn foo<'a>(arg : &'a [u32; 3]) -> &'a [u32] {
+  arg : &[u32]
+}
+
+fn main() {
+  let arr = [4,5,6];
+  let _ = foo(&arr);
+}

src/test/ui/coercion/type-ascription/coerce-union-field.rs

@@ -0,0 +1,14 @@
+// build-pass
+
+#![feature(type_ascription)]
+
+union Foo<'a> {
+    f1: (&'a u32, (u32, &'a [u32])),
+    _f2: u32,
+}
+
+fn main() {
+  let arr = [4,5,6];
+  let x = &mut 26;
+  let _ = Foo { f1: (x : &u32, (5, &arr : &[u32])) };
+}

src/test/ui/coercion/type-ascription/unsound-type-ascription-coercion.rs

@@ -0,0 +1,17 @@
+#![feature(type_ascription)]
+
+fn f() {
+  let mut x: &'static u32 = &22;
+  let y = &44;
+  foo(x, y);
+}
+
+fn foo<'a, 'b>(arg1 : &'a u32, arg2 : &'b u32) {
+  let p = &mut (arg1 : &'b u32);
+    //~^ ERROR: type ascriptions are not allowed
+  *p = arg2;
+}
+
+fn main() {
+  f();
+}

src/test/ui/coercion/type-ascription/unsound-type-ascription-coercion.stderr

@@ -0,0 +1,8 @@
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/unsound-type-ascription-coercion.rs:10:16
+   |
+LL |   let p = &mut (arg1 : &'b u32);
+   |                ^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+

src/test/ui/panic-handler/panic-handler-requires-panic-info.stderr

@@ -1,4 +1,6 @@
 error: language item required, but not found: `panic_info`
 
-error: aborting due to previous error
+error: requires `copy` lang_item
+
+error: aborting due to 2 previous errors
 

src/test/ui/raw-ref-op/raw-ref-temp.stderr

@@ -94,6 +94,30 @@ error[E0745]: cannot take address of a temporary
 LL |     let ascribe_index_ref = &raw mut (ARRAY[0]: i32);
    |                                      ^^^^^^^^^^^^^^^ temporary value
 
-error: aborting due to 16 previous errors
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/raw-ref-temp.rs:26:34
+   |
+LL |     let ref_ascribe = &raw const (2: i32);
+   |                                  ^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/raw-ref-temp.rs:27:36
+   |
+LL |     let mut_ref_ascribe = &raw mut (3: i32);
+   |                                    ^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/raw-ref-temp.rs:29:40
+   |
+LL |     let ascribe_field_ref = &raw const (PAIR.0: i32);
+   |                                        ^^^^^^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/raw-ref-temp.rs:30:38
+   |
+LL |     let ascribe_index_ref = &raw mut (ARRAY[0]: i32);
+   |                                      ^^^^^^^^^^^^^^^
+
+error: aborting due to 20 previous errors
 
 For more information about this error, try `rustc --explain E0745`.

src/test/ui/type-ascription/as_ref.rs

@@ -0,0 +1,27 @@
+#![feature(type_ascription)]
+
+use std::convert::AsRef;
+
+struct Foo {
+  a : u32,
+}
+
+impl AsRef<Foo> for Foo {
+  fn as_ref(&self) -> &Foo {
+    &self
+  }
+}
+
+fn main() {
+  let foo = Foo { a : 1 };
+  let r = &mut foo;
+
+  let x = (r : &Foo).as_ref();
+    //~^ ERROR: type ascriptions are not 
+
+  let another_one = (r : &Foo).as_ref().a;
+    //~^ ERROR: type ascriptions are not 
+
+  let last_one = &*((r : &Foo).as_ref());
+    //~^ ERROR: type ascriptions are not 
+}

src/test/ui/type-ascription/as_ref.stderr

@@ -0,0 +1,46 @@
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/as_ref.rs:19:11
+   |
+LL |   let x = (r : &Foo).as_ref();
+   |           ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &Foo = &mut foo;
+   | ^^^^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/as_ref.rs:22:21
+   |
+LL |   let another_one = (r : &Foo).as_ref().a;
+   |                     ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &Foo = &mut foo;
+   | ^^^^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/as_ref.rs:25:21
+   |
+LL |   let last_one = &*((r : &Foo).as_ref());
+   |                     ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &Foo = &mut foo;
+   | ^^^^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/as_ref.rs:25:21
+   |
+LL |   let last_one = &*((r : &Foo).as_ref());
+   |                     ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &Foo = &mut foo;
+   | ^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+

src/test/ui/type-ascription/assign.rs

@@ -0,0 +1,9 @@
+#![feature(type_ascription)]
+
+fn main() {
+  let arr1 = [4,5,6];
+  let arr2 = [2,2,2];
+  let mut x = &arr1;
+  x : &[u32] = &arr2;
+    //~^ ERROR type ascriptions are not allowed
+}

src/test/ui/type-ascription/assign.stderr

@@ -0,0 +1,8 @@
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/assign.rs:7:3
+   |
+LL |   x : &[u32] = &arr2;
+   |   ^^^^^^^^^^
+
+error: aborting due to previous error
+

src/test/ui/type-ascription/automatic_reborrows.rs

@@ -0,0 +1,21 @@
+#![feature(type_ascription)]
+
+struct Foo<'a> {
+  a : &'a [u32], 
+}
+
+impl Foo<'_> {
+  fn foo_that<'a>(&self, p : &'a [u32]) {}
+}  
+
+
+fn main() {
+  let arr = [4,5,6];
+  let r = &arr;
+  let foo = Foo {a : (r : &[u32]) };
+    //~^ ERROR: type ascriptions are not
+
+  let fooer = Foo {a : r};
+  fooer.foo_that(r : &[u32]);
+    //~^ ERROR: type ascriptions are not
+}

src/test/ui/type-ascription/automatic_reborrows.stderr

@@ -0,0 +1,24 @@
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/automatic_reborrows.rs:15:22
+   |
+LL |   let foo = Foo {a : (r : &[u32]) };
+   |                      ^^^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &[u32] = &arr;
+   | ^^^^^^^^^^^^^
+
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/automatic_reborrows.rs:19:18
+   |
+LL |   fooer.foo_that(r : &[u32]);
+   |                  ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let r: &[u32] = &arr;
+   | ^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

src/test/ui/type-ascription/autoref-method.rs

@@ -0,0 +1,14 @@
+#![feature(type_ascription)]
+
+struct Foo {}
+
+impl Foo {
+  fn foo(&self) {}
+}
+
+fn main() {
+  let mut fooer = Foo {};
+  let x = &mut fooer;
+  (x : &Foo).foo(); 
+    //~^ ERROR: type ascriptions are not allowed
+}

src/test/ui/type-ascription/autoref-method.stderr

@@ -0,0 +1,13 @@
+error: type ascriptions are not allowed in lvalue contexts
+  --> $DIR/autoref-method.rs:12:3
+   |
+LL |   (x : &Foo).foo(); 
+   |   ^^^^^^^^^^
+   |
+help: try to use the type ascription when creating the local variable
+   |
+LL | let x: &Foo = &mut fooer;
+   | ^^^^^^^^^^^
+
+error: aborting due to previous error
+

src/test/ui/type-ascription/borrow.rs

@@ -0,0 +1,21 @@
+#![feature(type_ascription)]
+
+struct Foo {
+  a : u32,
+}
+
+fn main() {
+  let foo = Foo { a : 1 };
+  let r = &mut foo;
+
+  let x = &(r : &Foo);
+    //~^ ERROR: type ascriptions are not
+
+  let another_one = &(r : &Foo).a;
+    //~^ ERROR: type ascriptions are not
+
+  let arr = [4,5,6];
+  let arr_ref = &arr;
+  let ref last_one = &(arr_ref : &[u32])[1];
+    //~^ ERROR: type ascriptions are not
+}