Migrate 11 tests from tests/ui/issues to specific directories

tests/ui/imports/auxiliary/extern-crate-indirect-fn-ptr-aux-2.rs

@@ -0,0 +1,3 @@
+extern crate extern_crate_indirect_fn_ptr_aux_1 as crate1;
+
+pub static FOO2: crate1::Foo = crate1::FOO;

tests/ui/imports/auxiliary/extern-crate-no-prefer-dynamic-aux-2.rs

@@ -0,0 +1,3 @@
+extern crate extern_crate_no_prefer_dynamic_aux_1;
+
+pub fn bar() {}

tests/ui/imports/extern-crate-alias-impl-method.rs

@@ -0,0 +1,16 @@
+// issue: <https://github.com/rust-lang/rust/issues/14422>
+// Test that we can call an inherently implemented method via aliasing from an extern crate.
+//@ run-pass
+#![allow(non_snake_case)]
+
+//@ aux-build:extern-crate-alias-impl-method-aux.rs
+
+extern crate extern_crate_alias_impl_method_aux as bug_lib;
+
+use bug_lib::B;
+use bug_lib::make;
+
+pub fn main() {
+    let mut an_A: B = make();
+    an_A.foo();
+}

tests/ui/imports/extern-crate-indirect-fn-ptr.rs

@@ -0,0 +1,11 @@
+// issue: <https://github.com/rust-lang/rust/issues/13620>
+// Test cross crate resolution of an indirect function pointer
+//@ run-pass
+//@ aux-build:extern-crate-indirect-fn-ptr-aux-1.rs
+//@ aux-build:extern-crate-indirect-fn-ptr-aux-2.rs
+
+extern crate extern_crate_indirect_fn_ptr_aux_2 as crate2;
+
+fn main() {
+    (crate2::FOO2.foo)();
+}

tests/ui/imports/extern-crate-no-prefer-dynamic.rs

@@ -0,0 +1,13 @@
+// issue: <https://github.com/rust-lang/rust/issues/14344>
+// Test that we can depend on an `no-prefer-dynamic` crate.
+//@ run-pass
+//@ aux-build:extern-crate-no-prefer-dynamic-aux-1.rs
+//@ aux-build:extern-crate-no-prefer-dynamic-aux-2.rs
+
+extern crate extern_crate_no_prefer_dynamic_aux_1;
+extern crate extern_crate_no_prefer_dynamic_aux_2;
+
+fn main() {
+    extern_crate_no_prefer_dynamic_aux_1::foo();
+    extern_crate_no_prefer_dynamic_aux_2::bar();
+}

tests/ui/issues/issue-15562.rs → tests/ui/imports/extern-transmute.rs

@@ -1,8 +1,9 @@
+// issue: <https://github.com/rust-lang/rust/issues/15562>
+// Test resolution of `transmute` in an extern block to rust intrinsics.
 //@ run-pass
-//@ aux-build:issue-15562.rs
+//@ aux-build:extern-transmute-aux.rs
 
-
-extern crate issue_15562 as i;
+extern crate extern_transmute_aux as i;
 
 pub fn main() {
     unsafe {

tests/ui/issues/issue-13507-2.rs → tests/ui/imports/typeid-cross-crate.rs

@@ -1,14 +1,16 @@
+// issue: <https://github.com/rust-lang/rust/issues/13507>
+// Test cross-crate TypeId stability
 //@ run-pass
 #![allow(unused_imports)]
-//@ aux-build:issue-13507.rs
+//@ aux-build:typeid-cross-crate-aux.rs
 
-extern crate issue_13507;
-use issue_13507::testtypes;
+extern crate typeid_cross_crate_aux;
+use typeid_cross_crate_aux::testtypes;
 
 use std::any::TypeId;
 
 pub fn type_ids() -> Vec<TypeId> {
-    use issue_13507::testtypes::*;
+    use typeid_cross_crate_aux::testtypes::*;
     vec![
         TypeId::of::<FooBool>(),
         TypeId::of::<FooInt>(),
@@ -25,12 +27,12 @@ pub fn type_ids() -> Vec<TypeId> {
         TypeId::of::<FooTuple>(),
         TypeId::of::<dyn FooTrait>(),
         TypeId::of::<FooStruct>(),
-        TypeId::of::<FooEnum>()
+        TypeId::of::<FooEnum>(),
     ]
 }
 
 pub fn main() {
-    let othercrate = issue_13507::testtypes::type_ids();
+    let othercrate = typeid_cross_crate_aux::testtypes::type_ids();
     let thiscrate = type_ids();
     assert_eq!(thiscrate, othercrate);
 }

tests/ui/imports/unused-cross-crate-import.rs

@@ -0,0 +1,15 @@
+// issue: <https://github.com/rust-lang/rust/issues/12612>
+// Test that unused `use` declarations involving multiple external crates are handled properly.
+//@ run-pass
+#![allow(unused_imports)]
+//@ aux-build:unused-cross-crate-import-aux-1.rs
+//@ aux-build:unused-cross-crate-import-aux-2.rs
+
+extern crate unused_cross_crate_import_aux_1 as foo;
+extern crate unused_cross_crate_import_aux_2 as bar;
+
+mod test {
+    use bar::baz;
+}
+
+fn main() {}

tests/ui/imports/unused-extern-crate.rs

@@ -0,0 +1,8 @@
+// issue: <https://github.com/rust-lang/rust/issues/11224>
+// Test that an unused `extern crate` declaration does not crash the compiler.
+//@ run-pass
+//@ aux-build:unused-extern-crate-aux.rs
+
+extern crate unused_extern_crate_aux as unused;
+
+pub fn main() {}

tests/ui/lint/missing-docs-private-trait.rs

@@ -0,0 +1,17 @@
+// issue: <https://github.com/rust-lang/rust/issues/11592>
+// Test that the `missing_docs` lint does not trigger for a private trait.
+//@ check-pass
+//! Ensure the private trait Bar isn't complained about.
+
+#![deny(missing_docs)]
+
+mod foo {
+    trait Bar {
+        fn bar(&self) {}
+    }
+    impl Bar for i8 {
+        fn bar(&self) {}
+    }
+}
+
+fn main() {}

tests/ui/pattern/box-pattern-nested.rs

@@ -0,0 +1,24 @@
+// issue: <https://github.com/rust-lang/rust/issues/11552>
+// Test nested box pattern matching inside a larger `match` statement.
+//@ run-pass
+#![feature(box_patterns)]
+
+#[derive(Clone)]
+enum Noun {
+    Atom(isize),
+    Cell(Box<Noun>, Box<Noun>),
+}
+
+fn fas(n: &Noun) -> Noun {
+    match n {
+        &Noun::Cell(box Noun::Atom(2), box Noun::Cell(ref a, _)) => (**a).clone(),
+        _ => panic!("Invalid fas pattern"),
+    }
+}
+
+pub fn main() {
+    fas(&Noun::Cell(
+        Box::new(Noun::Atom(2)),
+        Box::new(Noun::Cell(Box::new(Noun::Atom(2)), Box::new(Noun::Atom(3)))),
+    ));
+}

tests/ui/pattern/tuple-struct-cross-crate.rs

@@ -0,0 +1,13 @@
+// issue: <https://github.com/rust-lang/rust/issues/11508>
+// Test pattern matching on a tuple struct defined in an external crate.
+//@ run-pass
+//@ aux-build:tuple-struct-cross-crate-aux.rs
+
+extern crate tuple_struct_cross_crate_aux as rand;
+
+use rand::{Closed01, random};
+
+fn main() {
+    let Closed01(val) = random::<Closed01<f32>>();
+    println!("{}", val);
+}

tests/ui/typeck/infer-struct-with-trait-object.rs

@@ -0,0 +1,27 @@
+// issue: <https://github.com/rust-lang/rust/issues/11677>
+// Test that type inference works correctly for struct fields containing trait objects.
+//@ run-pass
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+// this code used to cause an ICE
+
+use std::marker;
+
+trait X<T> {
+    fn dummy(&self) -> T {
+        panic!()
+    }
+}
+
+struct S<T> {
+    f: Box<dyn X<T> + 'static>,
+    g: Box<dyn X<T> + 'static>,
+}
+
+struct F;
+impl X<isize> for F {}
+
+fn main() {
+    S { f: Box::new(F), g: Box::new(F) };
+}