Remove box syntax from most places in src/test outside of the issues dir

src/test/debuginfo/borrowed-struct.rs

@@ -63,7 +63,6 @@
 // lldbr-check:(f64) *unique_val_interior_ref_2 = 26.5
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -79,7 +78,7 @@ fn main() {
     let stack_val_interior_ref_2: &f64 = &stack_val.y;
     let ref_to_unnamed: &SomeStruct = &SomeStruct { x: 11, y: 24.5 };
 
-    let unique_val: Box<_> = box SomeStruct { x: 13, y: 26.5 };
+    let unique_val: Box<_> = Box::new(SomeStruct { x: 13, y: 26.5 });
     let unique_val_ref: &SomeStruct = &*unique_val;
     let unique_val_interior_ref_1: &isize = &unique_val.x;
     let unique_val_interior_ref_2: &f64 = &unique_val.y;

src/test/debuginfo/borrowed-tuple.rs

@@ -37,7 +37,6 @@
 
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -46,7 +45,7 @@ fn main() {
     let stack_val_ref: &(i16, f32) = &stack_val;
     let ref_to_unnamed: &(i16, f32) = &(-15, -20f32);
 
-    let unique_val: Box<(i16, f32)> = box (-17, -22f32);
+    let unique_val: Box<(i16, f32)> = Box::new((-17, -22f32));
     let unique_val_ref: &(i16, f32) = &*unique_val;
 
     zzz(); // #break

src/test/debuginfo/borrowed-unique-basic.rs

@@ -116,51 +116,50 @@
 // lldbr-check:(f64) *f64_ref = 3.5
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
-    let bool_box: Box<bool> = box true;
+    let bool_box: Box<bool> = Box::new(true);
     let bool_ref: &bool = &*bool_box;
 
-    let int_box: Box<isize> = box -1;
+    let int_box: Box<isize> = Box::new(-1);
     let int_ref: &isize = &*int_box;
 
-    let char_box: Box<char> = box 'a';
+    let char_box: Box<char> = Box::new('a');
     let char_ref: &char = &*char_box;
 
-    let i8_box: Box<i8> = box 68;
+    let i8_box: Box<i8> = Box::new(68);
     let i8_ref: &i8 = &*i8_box;
 
-    let i16_box: Box<i16> = box -16;
+    let i16_box: Box<i16> = Box::new(-16);
     let i16_ref: &i16 = &*i16_box;
 
-    let i32_box: Box<i32> = box -32;
+    let i32_box: Box<i32> = Box::new(-32);
     let i32_ref: &i32 = &*i32_box;
 
-    let i64_box: Box<i64> = box -64;
+    let i64_box: Box<i64> = Box::new(-64);
     let i64_ref: &i64 = &*i64_box;
 
-    let uint_box: Box<usize> = box 1;
+    let uint_box: Box<usize> = Box::new(1);
     let uint_ref: &usize = &*uint_box;
 
-    let u8_box: Box<u8> = box 100;
+    let u8_box: Box<u8> = Box::new(100);
     let u8_ref: &u8 = &*u8_box;
 
-    let u16_box: Box<u16> = box 16;
+    let u16_box: Box<u16> = Box::new(16);
     let u16_ref: &u16 = &*u16_box;
 
-    let u32_box: Box<u32> = box 32;
+    let u32_box: Box<u32> = Box::new(32);
     let u32_ref: &u32 = &*u32_box;
 
-    let u64_box: Box<u64> = box 64;
+    let u64_box: Box<u64> = Box::new(64);
     let u64_ref: &u64 = &*u64_box;
 
-    let f32_box: Box<f32> = box 2.5;
+    let f32_box: Box<f32> = Box::new(2.5);
     let f32_ref: &f32 = &*f32_box;
 
-    let f64_box: Box<f64> = box 3.5;
+    let f64_box: Box<f64> = Box::new(3.5);
     let f64_ref: &f64 = &*f64_box;
 
     zzz(); // #break

src/test/debuginfo/box.rs

@@ -24,13 +24,12 @@
 // lldbr-check:((i32, f64)) *b = { 0 = 2 1 = 3.5 }
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
-    let a = box 1;
-    let b = box (2, 3.5f64);
+    let a = Box::new(1);
+    let b = Box::new((2, 3.5f64));
 
     zzz(); // #break
 }

src/test/debuginfo/boxed-struct.rs

@@ -28,7 +28,6 @@
 // lldbr-check:(boxed_struct::StructWithDestructor) *boxed_with_dtor = { x = 77 y = 777 z = 7777 w = 77777 }
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -52,9 +51,19 @@ impl Drop for StructWithDestructor {
 
 fn main() {
 
-    let boxed_with_padding: Box<_> = box StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 };
+    let boxed_with_padding: Box<_> = Box::new(StructWithSomePadding {
+        x: 99,
+        y: 999,
+        z: 9999,
+        w: 99999,
+    });
 
-    let boxed_with_dtor: Box<_> = box StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 };
+    let boxed_with_dtor: Box<_> = Box::new(StructWithDestructor {
+        x: 77,
+        y: 777,
+        z: 7777,
+        w: 77777,
+    });
     zzz(); // #break
 }
 

src/test/debuginfo/closure-in-generic-function.rs

@@ -39,7 +39,6 @@
 // lldbr-check:(i32) *y = 110
 // lldb-command:continue
 
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 

src/test/debuginfo/destructured-fn-argument.rs

@@ -358,7 +358,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -480,7 +479,7 @@ fn main() {
     managed_box(&(34, 35));
     borrowed_pointer(&(36, 37));
     contained_borrowed_pointer((&38, 39));
-    unique_pointer(box (40, 41, 42));
+    unique_pointer(Box::new((40, 41, 42)));
     ref_binding((43, 44, 45));
     ref_binding_in_tuple((46, (47, 48)));
     ref_binding_in_struct(Struct { a: 49, b: 50 });

src/test/debuginfo/destructured-for-loop-variable.rs

@@ -173,7 +173,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -214,7 +213,7 @@ fn main() {
             y: -300001.5,
             z: true
          },
-         box 854237.5);
+         Box::new(854237.5));
 
     for &(v1,
           &Struct { x: x1, y: ref y1, z: z1 },

src/test/debuginfo/destructured-local.rs

@@ -285,7 +285,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -345,7 +344,7 @@ fn main() {
     let (&cc, _) = (&38, 39);
 
     // unique pointer
-    let box dd = box (40, 41, 42);
+    let box dd = Box::new((40, 41, 42));
 
     // ref binding
     let ref ee = (43, 44, 45);

src/test/debuginfo/generic-method-on-generic-struct.rs

@@ -123,7 +123,6 @@
 // lldbr-check:(f32) arg2 = -10.5
 // lldb-command:continue
 
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -155,7 +154,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, 2_u16);
     let _ = stack.self_by_val(-3, -4_i16);
 
-    let owned: Box<_> = box Struct { x: 1234.5f64 };
+    let owned: Box<_> = Box::new(Struct { x: 1234.5f64 });
     let _ = owned.self_by_ref(-5, -6_i32);
     let _ = owned.self_by_val(-7, -8_i64);
     let _ = owned.self_owned(-9, -10.5_f32);

src/test/debuginfo/method-on-enum.rs

@@ -107,7 +107,6 @@
 // lldb-check:[...]$14 = -10
 // lldb-command:continue
 
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -140,7 +139,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box Enum::Variant1{ x: 1799, y: 1799 };
+    let owned: Box<_> = Box::new(Enum::Variant1{ x: 1799, y: 1799 });
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/method-on-generic-struct.rs

@@ -123,8 +123,6 @@
 // lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
-
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -156,7 +154,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box Struct { x: 1234.5f64 };
+    let owned: Box<_> = Box::new(Struct { x: 1234.5f64 });
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/method-on-struct.rs

@@ -121,8 +121,6 @@
 // lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
-
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -154,7 +152,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box Struct { x: 200 };
+    let owned: Box<_> = Box::new(Struct { x: 200 });
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/method-on-trait.rs

@@ -121,8 +121,6 @@
 // lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
-
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -160,7 +158,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box Struct { x: 200 };
+    let owned: Box<_> = Box::new(Struct { x: 200 });
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/method-on-tuple-struct.rs

@@ -121,8 +121,6 @@
 // lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
-
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -152,7 +150,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box TupleStruct(200, -200.5);
+    let owned: Box<_> = Box::new(TupleStruct(200, -200.5));
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/recursive-struct.rs

@@ -52,20 +52,20 @@
 // gdb-command:print long_cycle4.value
 // gdb-check:$18 = 29.5
 
-// gdbr-command:print long_cycle_w_anonymous_types.value
+// gdbr-command:print long_cycle_w_anon_types.value
 // gdb-check:$19 = 30
 
-// gdbr-command:print long_cycle_w_anonymous_types.next.val.value
+// gdbr-command:print long_cycle_w_anon_types.next.val.value
 // gdb-check:$20 = 31
 
 // gdb-command:continue
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 use self::Opt::{Empty, Val};
+use std::boxed::Box as B;
 
 enum Opt<T> {
     Empty,
@@ -120,75 +120,75 @@ struct LongCycleWithAnonymousTypes {
 fn main() {
     let stack_unique: UniqueNode<u16> = UniqueNode {
         next: Val {
-            val: box UniqueNode {
+            val: Box::new(UniqueNode {
                 next: Empty,
                 value: 1,
-            }
+            })
         },
         value: 0,
     };
 
-    let unique_unique: Box<UniqueNode<u32>> = box UniqueNode {
+    let unique_unique: Box<UniqueNode<u32>> = Box::new(UniqueNode {
         next: Val {
-            val: box UniqueNode {
+            val: Box::new(UniqueNode {
                 next: Empty,
                 value: 3,
-            }
+            })
         },
         value: 2,
-    };
+    });
 
     let vec_unique: [UniqueNode<f32>; 1] = [UniqueNode {
         next: Val {
-            val: box UniqueNode {
+            val: Box::new(UniqueNode {
                 next: Empty,
                 value: 7.5,
-            }
+            })
         },
         value: 6.5,
     }];
 
     let borrowed_unique: &UniqueNode<f64> = &UniqueNode {
         next: Val {
-            val: box UniqueNode {
+            val: Box::new(UniqueNode {
                 next: Empty,
                 value: 9.5,
-            }
+            })
         },
         value: 8.5,
     };
 
     // LONG CYCLE
     let long_cycle1: LongCycle1<u16> = LongCycle1 {
-        next: box LongCycle2 {
-            next: box LongCycle3 {
-                next: box LongCycle4 {
+        next: Box::new(LongCycle2 {
+            next: Box::new(LongCycle3 {
+                next: Box::new(LongCycle4 {
                     next: None,
                     value: 23,
-                },
+                }),
                 value: 22,
-            },
+            }),
             value: 21
-        },
+        }),
         value: 20
     };
 
     let long_cycle2: LongCycle2<u32> = LongCycle2 {
-        next: box LongCycle3 {
-            next: box LongCycle4 {
+        next: Box::new(LongCycle3 {
+            next: Box::new(LongCycle4 {
                 next: None,
                 value: 26,
-            },
+            }),
             value: 25,
-        },
+        }),
         value: 24
     };
 
     let long_cycle3: LongCycle3<u64> = LongCycle3 {
-        next: box LongCycle4 {
+        next: Box::new(LongCycle4 {
             next: None,
             value: 28,
-        },
+        }),
         value: 27,
     };
 
@@ -199,15 +199,15 @@ fn main() {
 
     // It's important that LongCycleWithAnonymousTypes is encountered only at the end of the
     // `box` chain.
-    let long_cycle_w_anonymous_types = box box box box box LongCycleWithAnonymousTypes {
+    let long_cycle_w_anon_types = B::new(B::new(B::new(B::new(B::new(LongCycleWithAnonymousTypes {
         next: Val {
-            val: box box box box box LongCycleWithAnonymousTypes {
+            val: Box::new(Box::new(Box::new(Box::new(Box::new(LongCycleWithAnonymousTypes {
                 next: Empty,
                 value: 31,
-            }
+            })))))
         },
         value: 30
-    };
+    })))));
 
     zzz(); // #break
 }

src/test/debuginfo/self-in-default-method.rs

@@ -121,7 +121,6 @@
 // lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -154,7 +153,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned: Box<_> = box Struct { x: 200 };
+    let owned: Box<_> = Box::new(Struct { x: 200 });
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);

src/test/debuginfo/self-in-generic-default-method.rs

@@ -121,7 +121,6 @@
 // lldbr-check:(f32) arg2 = -10.5
 // lldb-command:continue
 
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -155,7 +154,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, 2_u16);
     let _ = stack.self_by_val(-3, -4_i16);
 
-    let owned: Box<_> = box Struct { x: 879 };
+    let owned: Box<_> = Box::new(Struct { x: 879 });
     let _ = owned.self_by_ref(-5, -6_i32);
     let _ = owned.self_by_val(-7, -8_i64);
     let _ = owned.self_owned(-9, -10.5_f32);

src/test/debuginfo/trait-pointers.rs

@@ -5,7 +5,6 @@
 // lldb-command:run
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -24,5 +23,5 @@ impl Trait for Struct {}
 fn main() {
     let stack_struct = Struct { a:0, b: 1.0 };
     let reference: &Trait = &stack_struct as &Trait;
-    let unique: Box<Trait> = box Struct { a:2, b: 3.0 } as Box<Trait>;
+    let unique: Box<Trait> = Box::new(Struct { a:2, b: 3.0 }) as Box<Trait>;
 }

src/test/debuginfo/type-names.rs

@@ -262,7 +262,6 @@
 // cdb-check:struct ForeignType2 * foreign2 = [...]
 // cdb-check:struct ForeignType1 * foreign1 = [...]
 
-#![feature(box_syntax)]
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
@@ -373,8 +372,8 @@ fn main() {
     let tuple2 = ((Struct1, mod1::mod2::Struct3), mod1::Variant1, 'x');
 
     // Box
-    let box1 = (box 1f32, 0i32);
-    let box2 = (box mod1::mod2::Variant2(1f32), 0i32);
+    let box1 = (Box::new(1f32), 0i32);
+    let box2 = (Box::new(mod1::mod2::Variant2(1f32)), 0i32);
 
     // References
     let ref1 = (&Struct1, 0i32);
@@ -404,14 +403,14 @@ fn main() {
     let slice2 = &*vec2;
 
     // Trait Objects
-    let box_trait = (box 0_isize) as Box<dyn Trait1>;
+    let box_trait = Box::new(0_isize) as Box<dyn Trait1>;
     let ref_trait = &0_isize as &dyn Trait1;
     let mut mut_int1 = 0_isize;
     let mut_ref_trait = (&mut mut_int1) as &mut dyn Trait1;
-    let no_principal_trait = (box 0_isize) as Box<(dyn Send + Sync)>;
+    let no_principal_trait = Box::new(0_isize) as Box<(dyn Send + Sync)>;
     let has_associated_type_trait = &0_isize as &(dyn Trait3<u32, AssocType = isize> + Send);
 
-    let generic_box_trait = (box 0_isize) as Box<dyn Trait2<i32, mod1::Struct2>>;
+    let generic_box_trait = Box::new(0_isize) as Box<dyn Trait2<i32, mod1::Struct2>>;
     let generic_ref_trait = (&0_isize) as &dyn Trait2<Struct1, Struct1>;
 
     let mut generic_mut_ref_trait_impl = 0_isize;

src/test/debuginfo/unique-enum.rs

@@ -32,7 +32,6 @@
 // lldbr-check:(unique_enum::Univariant) *univariant = { TheOnlyCase = { = 123234 } }
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -59,15 +58,15 @@ fn main() {
     // 0b01111100011111000111110001111100 = 2088533116
     // 0b0111110001111100 = 31868
     // 0b01111100 = 124
-    let the_a: Box<_> = box ABC::TheA { x: 0, y: 8970181431921507452 };
+    let the_a: Box<_> = Box::new(ABC::TheA { x: 0, y: 8970181431921507452 });
 
     // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
     // 0b00010001000100010001000100010001 = 286331153
     // 0b0001000100010001 = 4369
     // 0b00010001 = 17
-    let the_b: Box<_> = box ABC::TheB (0, 286331153, 286331153);
+    let the_b: Box<_> = Box::new(ABC::TheB (0, 286331153, 286331153));
 
-    let univariant: Box<_> = box Univariant::TheOnlyCase(123234);
+    let univariant: Box<_> = Box::new(Univariant::TheOnlyCase(123234));
 
     zzz(); // #break
 }

src/test/debuginfo/var-captured-in-nested-closure.rs

@@ -133,7 +133,6 @@
 // cdb-check:closure_local    : 8 [Type: [...]]
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -154,7 +153,7 @@ fn main() {
     };
 
     let struct_ref = &a_struct;
-    let owned: Box<_> = box 6;
+    let owned: Box<_> = Box::new(6);
 
     let mut closure = || {
         let closure_local = 8;

src/test/debuginfo/var-captured-in-sendable-closure.rs

@@ -34,7 +34,6 @@
 // lldbr-check:(isize) *owned = 5
 
 #![allow(unused_variables)]
-#![feature(box_syntax)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
@@ -53,7 +52,7 @@ fn main() {
         c: 4
     };
 
-    let owned: Box<_> = box 5;
+    let owned: Box<_> = Box::new(5);
 
     let closure = move || {
         zzz(); // #break

src/test/debuginfo/var-captured-in-stack-closure.rs

@@ -115,7 +115,6 @@
 // cdb-command: dx owned
 // cdb-check:owned            : 0x[...] : 6 [Type: [...] *]
 
-#![feature(box_syntax)]
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
@@ -137,7 +136,7 @@ fn main() {
     };
 
     let struct_ref = &a_struct;
-    let owned: Box<_> = box 6;
+    let owned: Box<_> = Box::new(6);
 
     {
         let mut first_closure = || {

src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs

@@ -1,4 +1,4 @@
-#![feature(box_syntax, plugin, rustc_private)]
+#![feature(plugin, rustc_private)]
 #![crate_type = "dylib"]
 
 extern crate rustc_ast_pretty;
@@ -21,7 +21,7 @@ use rustc_span::source_map;
 #[no_mangle]
 fn __rustc_plugin_registrar(reg: &mut Registry) {
     reg.lint_store.register_lints(&[&MISSING_ALLOWED_ATTR]);
-    reg.lint_store.register_late_pass(|| box MissingAllowedAttrPass);
+    reg.lint_store.register_late_pass(|| Box::new(MissingAllowedAttrPass));
 }
 
 declare_lint! {

src/test/ui-fulldeps/auxiliary/lint-for-crate-rpass.rs

@@ -1,7 +1,6 @@
 // force-host
 
 #![feature(rustc_private)]
-#![feature(box_syntax)]
 
 extern crate rustc_driver;
 extern crate rustc_hir;
@@ -73,7 +72,7 @@ fn __rustc_plugin_registrar(reg: &mut Registry) {
         &CRATE_NOT_GREY,
         &CRATE_NOT_GREEN,
     ]);
-    reg.lint_store.register_late_pass(|| box PassOkay);
-    reg.lint_store.register_late_pass(|| box PassRedBlue);
-    reg.lint_store.register_late_pass(|| box PassGreyGreen);
+    reg.lint_store.register_late_pass(|| Box::new(PassOkay));
+    reg.lint_store.register_late_pass(|| Box::new(PassRedBlue));
+    reg.lint_store.register_late_pass(|| Box::new(PassGreyGreen));
 }

src/test/ui-fulldeps/auxiliary/lint-for-crate.rs

@@ -1,7 +1,6 @@
 // force-host
 
 #![feature(rustc_private)]
-#![feature(box_syntax)]
 
 extern crate rustc_driver;
 extern crate rustc_hir;
@@ -41,5 +40,5 @@ impl<'tcx> LateLintPass<'tcx> for Pass {
 #[no_mangle]
 fn __rustc_plugin_registrar(reg: &mut Registry) {
     reg.lint_store.register_lints(&[&CRATE_NOT_OKAY]);
-    reg.lint_store.register_late_pass(|| box Pass);
+    reg.lint_store.register_late_pass(|| Box::new(Pass));
 }

src/test/ui-fulldeps/auxiliary/lint-group-plugin-test.rs

@@ -1,6 +1,6 @@
 // force-host
 
-#![feature(box_syntax, rustc_private)]
+#![feature(rustc_private)]
 
 // Load rustc as a plugin to get macros.
 extern crate rustc_driver;
@@ -36,7 +36,7 @@ impl<'tcx> LateLintPass<'tcx> for Pass {
 #[no_mangle]
 fn __rustc_plugin_registrar(reg: &mut Registry) {
     reg.lint_store.register_lints(&[&TEST_LINT, &PLEASE_LINT]);
-    reg.lint_store.register_late_pass(|| box Pass);
+    reg.lint_store.register_late_pass(|| Box::new(Pass));
     reg.lint_store.register_group(
         true,
         "lint_me",

src/test/ui-fulldeps/auxiliary/lint-plugin-test.rs

@@ -1,6 +1,6 @@
 // force-host
 
-#![feature(box_syntax, rustc_private)]
+#![feature(rustc_private)]
 
 extern crate rustc_ast;
 
@@ -31,5 +31,5 @@ impl EarlyLintPass for Pass {
 #[no_mangle]
 fn __rustc_plugin_registrar(reg: &mut Registry) {
     reg.lint_store.register_lints(&[&TEST_LINT]);
-    reg.lint_store.register_early_pass(|| box Pass);
+    reg.lint_store.register_early_pass(|| Box::new(Pass));
 }

src/test/ui-fulldeps/auxiliary/lint-tool-test.rs

@@ -1,4 +1,4 @@
-#![feature(box_syntax, rustc_private)]
+#![feature(rustc_private)]
 
 extern crate rustc_ast;
 
@@ -46,7 +46,7 @@ impl EarlyLintPass for Pass {
 #[no_mangle]
 fn __rustc_plugin_registrar(reg: &mut Registry) {
     reg.lint_store.register_lints(&[&TEST_RUSTC_TOOL_LINT, &TEST_LINT, &TEST_GROUP]);
-    reg.lint_store.register_early_pass(|| box Pass);
+    reg.lint_store.register_early_pass(|| Box::new(Pass));
     reg.lint_store.register_group(
         true,
         "clippy::group",

src/test/ui-fulldeps/auxiliary/outlive-expansion-phase.rs

@@ -1,6 +1,6 @@
 // force-host
 
-#![feature(box_syntax, rustc_private)]
+#![feature(rustc_private)]
 
 extern crate rustc_middle;
 extern crate rustc_driver;
@@ -20,5 +20,5 @@ impl Drop for Foo {
 #[no_mangle]
 fn __rustc_plugin_registrar(_: &mut Registry) {
     thread_local!(static FOO: RefCell<Option<Box<Any+Send>>> = RefCell::new(None));
-    FOO.with(|s| *s.borrow_mut() = Some(box Foo { foo: 10 } as Box<Any+Send>));
+    FOO.with(|s| *s.borrow_mut() = Some(Box::new(Foo { foo: 10 }) as Box<Any+Send>));
 }

src/test/ui-fulldeps/deriving-encodable-decodable-box.rs

@@ -1,7 +1,6 @@
 // run-pass
 
 #![allow(unused_imports)]
-#![feature(box_syntax)]
 #![feature(rustc_private)]
 
 extern crate rustc_macros;

src/test/ui/alignment-gep-tup-like-1.rs

@@ -3,8 +3,6 @@
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
 
-#![feature(box_syntax)]
-
 struct pair<A,B> {
     a: A, b: B
 }
@@ -25,10 +23,10 @@ impl<A:Clone> Invokable<A> for Invoker<A> {
 }
 
 fn f<A:Clone + 'static>(a: A, b: u16) -> Box<dyn Invokable<A>+'static> {
-    box Invoker {
+    Box::new(Invoker {
         a: a,
         b: b,
-    } as Box<dyn Invokable<A>+'static>
+    }) as Box<dyn Invokable<A>+'static>
 }
 
 pub fn main() {

src/test/ui/array-slice-vec/vec-dst.rs

@@ -1,11 +1,9 @@
 // run-pass
 
-#![feature(box_syntax)]
-
 pub fn main() {
-    // Tests for indexing into box/& [T; n]
+    // Tests for indexing into Box<[T; n]>/& [T; n]
     let x: [isize; 3] = [1, 2, 3];
-    let mut x: Box<[isize; 3]> = box x;
+    let mut x: Box<[isize; 3]> = x.into();
     assert_eq!(x[0], 1);
     assert_eq!(x[1], 2);
     assert_eq!(x[2], 3);

src/test/ui/array-slice-vec/vector-no-ann-2.rs

@@ -2,6 +2,6 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(box_syntax)]
-
-pub fn main() { let _quux: Box<Vec<usize>> = box Vec::new(); }
+pub fn main() {
+    let _quux: Box<Vec<usize>> = Box::new(Vec::new());
+}

src/test/ui/associated-types/associated-types-doubleendediterator-object.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 fn pairwise_sub(mut t: Box<dyn DoubleEndedIterator<Item=isize>>) -> isize {
     let mut result = 0;

src/test/ui/autoderef-full-lval.rs

@@ -1,23 +1,23 @@
-#![feature(box_syntax)]
-
 struct Clam {
     x: Box<isize>,
     y: Box<isize>,
 }
 
+
+
 struct Fish {
     a: Box<isize>,
 }
 
 fn main() {
-    let a: Clam = Clam{x: box 1, y: box 2};
-    let b: Clam = Clam{x: box 10, y: box 20};
+    let a: Clam = Clam{ x: Box::new(1), y: Box::new(2) };
+    let b: Clam = Clam{ x: Box::new(10), y: Box::new(20) };
     let z: isize = a.x + b.y;
     //~^ ERROR cannot add `Box<isize>` to `Box<isize>`
     println!("{}", z);
     assert_eq!(z, 21);
-    let forty: Fish = Fish{a: box 40};
-    let two: Fish = Fish{a: box 2};
+    let forty: Fish = Fish{ a: Box::new(40) };
+    let two: Fish = Fish{ a: Box::new(2) };
     let answer: isize = forty.a + two.a;
     //~^ ERROR cannot add `Box<isize>` to `Box<isize>`
     println!("{}", answer);

src/test/ui/autoref-autoderef/autoderef-method-on-trait.rs

@@ -1,6 +1,5 @@
 // run-pass
 #![allow(non_camel_case_types)]
-#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> usize;
@@ -11,6 +10,6 @@ impl double for usize {
 }
 
 pub fn main() {
-    let x: Box<_> = box (box 3usize as Box<dyn double>);
+    let x: Box<_> = Box::new(Box::new(3usize) as Box<dyn double>);
     assert_eq!(x.double(), 6);
 }

src/test/ui/autoref-autoderef/autoderef-method-priority.rs

@@ -1,6 +1,5 @@
 // run-pass
 #![allow(non_camel_case_types)]
-#![feature(box_syntax)]
 
 trait double {
     fn double(self) -> usize;
@@ -15,6 +14,6 @@ impl double for Box<usize> {
 }
 
 pub fn main() {
-    let x: Box<_> = box 3;
+    let x: Box<_> = Box::new(3);
     assert_eq!(x.double(), 6);
 }

src/test/ui/autoref-autoderef/autoderef-method-twice-but-not-thrice.rs

@@ -1,6 +1,5 @@
 // run-pass
 #![allow(non_camel_case_types)]
-#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> usize;
@@ -11,6 +10,6 @@ impl double for Box<usize> {
 }
 
 pub fn main() {
-    let x: Box<Box<Box<Box<Box<_>>>>> = box box box box box 3;
+    let x: Box<Box<Box<Box<Box<_>>>>> = Box::new(Box::new(Box::new(Box::new(Box::new(3)))));
     assert_eq!(x.double(), 6);
 }

src/test/ui/autoref-autoderef/autoderef-method-twice.rs

@@ -1,6 +1,5 @@
 // run-pass
 #![allow(non_camel_case_types)]
-#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> usize;
@@ -11,6 +10,6 @@ impl double for usize {
 }
 
 pub fn main() {
-    let x: Box<Box<_>> = box box 3;
+    let x: Box<Box<_>> = Box::new(Box::new(3));
     assert_eq!(x.double(), 6);
 }

src/test/ui/autoref-autoderef/autoderef-method.rs

@@ -1,6 +1,5 @@
 // run-pass
 #![allow(non_camel_case_types)]
-#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> usize;
@@ -11,6 +10,6 @@ impl double for usize {
 }
 
 pub fn main() {
-    let x: Box<_> = box 3;
+    let x: Box<_> = Box::new(3);
     assert_eq!(x.double(), 6);
 }

src/test/ui/autoref-autoderef/autoref-intermediate-types-issue-3585.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 trait Foo {
     fn foo(&self) -> String;
@@ -18,6 +17,6 @@ impl Foo for usize {
 }
 
 pub fn main() {
-    let x: Box<_> = box 3;
+    let x: Box<_> = Box::new(3);
     assert_eq!(x.foo(), "box 3".to_string());
 }

src/test/ui/binding/expr-match-generic-unique1.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 fn test_generic<T: Clone, F>(expected: Box<T>, eq: F) where F: FnOnce(Box<T>, Box<T>) -> bool {
     let actual: Box<T> = match true {
@@ -13,7 +12,7 @@ fn test_box() {
     fn compare_box(b1: Box<bool>, b2: Box<bool>) -> bool {
         return *b1 == *b2;
     }
-    test_generic::<bool, _>(box true, compare_box);
+    test_generic::<bool, _>(Box::new(true), compare_box);
 }
 
 pub fn main() { test_box(); }

src/test/ui/binding/expr-match-generic-unique2.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
     let actual: T = match true {
@@ -11,7 +10,7 @@ fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
 
 fn test_vec() {
     fn compare_box(v1: Box<isize>, v2: Box<isize>) -> bool { return v1 == v2; }
-    test_generic::<Box<isize>, _>(box 1, compare_box);
+    test_generic::<Box<isize>, _>(Box::new(1), compare_box);
 }
 
 pub fn main() { test_vec(); }

src/test/ui/binding/expr-match-unique.rs

@@ -1,9 +1,8 @@
 // run-pass
-#![feature(box_syntax)]
 
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
-    let res: Box<_> = match true { true => { box 100 }, _ => panic!() };
+    let res: Box<_> = match true { true => { Box::new(100) }, _ => panic!() };
     assert_eq!(*res, 100);
 }
 

src/test/ui/binding/func-arg-incomplete-pattern.rs

@@ -3,8 +3,6 @@
 // Test that we do not leak when the arg pattern must drop part of the
 // argument (in this case, the `y` field).
 
-#![feature(box_syntax)]
-
 struct Foo {
     x: Box<usize>,
     y: Box<usize>,
@@ -16,9 +14,9 @@ fn foo(Foo {x, ..}: Foo) -> *const usize {
 }
 
 pub fn main() {
-    let obj: Box<_> = box 1;
+    let obj: Box<_> = Box::new(1);
     let objptr: *const usize = &*obj;
-    let f = Foo {x: obj, y: box 2};
+    let f = Foo { x: obj, y: Box::new(2) };
     let xptr = foo(f);
     assert_eq!(objptr, xptr);
 }

src/test/ui/binding/func-arg-ref-pattern.rs

@@ -5,7 +5,6 @@
 // pattern.
 
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 
 fn getaddr(box ref x: Box<usize>) -> *const usize {
     let addr: *const usize = &*x;
@@ -17,11 +16,11 @@ fn checkval(box ref x: Box<usize>) -> usize {
 }
 
 pub fn main() {
-    let obj: Box<_> = box 1;
+    let obj: Box<_> = Box::new(1);
     let objptr: *const usize = &*obj;
     let xptr = getaddr(obj);
     assert_eq!(objptr, xptr);
 
-    let obj = box 22;
+    let obj = Box::new(22);
     assert_eq!(checkval(obj), 22);
 }

src/test/ui/binding/let-assignability.rs

@@ -1,8 +1,7 @@
 // run-pass
-#![feature(box_syntax)]
 
 fn f() {
-    let a: Box<_> = box 1;
+    let a: Box<_> = Box::new(1);
     let b: &isize = &*a;
     println!("{}", b);
 }

src/test/ui/binding/match-implicit-copy-unique.rs

@@ -1,16 +1,15 @@
 // run-pass
 #![allow(non_shorthand_field_patterns)]
-#![feature(box_syntax)]
 
 struct Pair { a: Box<isize>, b: Box<isize> }
 
 pub fn main() {
-    let mut x: Box<_> = box Pair {a: box 10, b: box 20};
+    let mut x: Box<_> = Box::new(Pair { a: Box::new(10), b: Box::new(20) });
     let x_internal = &mut *x;
     match *x_internal {
       Pair {a: ref mut a, b: ref mut _b} => {
         assert_eq!(**a, 10);
-        *a = box 30;
+        *a = Box::new(30);
         assert_eq!(**a, 30);
       }
     }

src/test/ui/binding/match-unique-bind.rs

@@ -1,9 +1,8 @@
 // run-pass
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 
 pub fn main() {
-    match box 100 {
+    match Box::new(100) {
       box x => {
         println!("{}", x);
         assert_eq!(x, 100);

src/test/ui/binding/match-value-binding-in-guard-3291.rs

@@ -1,8 +1,6 @@
 // run-pass
 // pretty-expanded FIXME #23616
 
-#![feature(box_syntax)]
-
 fn foo(x: Option<Box<isize>>, b: bool) -> isize {
     match x {
       None => { 1 }
@@ -12,8 +10,8 @@ fn foo(x: Option<Box<isize>>, b: bool) -> isize {
 }
 
 pub fn main() {
-    foo(Some(box 22), true);
-    foo(Some(box 22), false);
+    foo(Some(Box::new(22)), true);
+    foo(Some(Box::new(22)), false);
     foo(None, true);
     foo(None, false);
 }

src/test/ui/borrowck/borrow-tuple-fields.rs

@@ -1,13 +1,13 @@
-#![feature(box_syntax)]
-
-
-
 struct Foo(Box<isize>, isize);
 
 struct Bar(isize, isize);
 
+
+
+
+
 fn main() {
-    let x: (Box<_>, _) = (box 1, 2);
+    let x: (Box<_>, _) = (Box::new(1), 2);
     let r = &x.0;
     let y = x; //~ ERROR cannot move out of `x` because it is borrowed
 
@@ -23,7 +23,7 @@ fn main() {
     let b = &mut x.0; //~ ERROR cannot borrow `x.0` as mutable more than once at a time
     a.use_ref();
 
-    let x = Foo(box 1, 2);
+    let x = Foo(Box::new(1), 2);
     let r = &x.0;
     let y = x; //~ ERROR cannot move out of `x` because it is borrowed
     r.use_ref();

src/test/ui/borrowck/borrowck-bad-nested-calls-free.rs

@@ -1,10 +1,10 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
-#![feature(box_syntax)]
+
 
 fn rewrite(v: &mut Box<usize>) -> usize {
-    *v = box 22;
+    *v = Box::new(22);
     **v
 }
 
@@ -13,7 +13,7 @@ fn add(v: &usize, w: usize) -> usize {
 }
 
 fn implicit() {
-    let mut a: Box<_> = box 1;
+    let mut a: Box<_> = Box::new(1);
 
     // Note the danger here:
     //
@@ -26,7 +26,7 @@ fn implicit() {
 }
 
 fn explicit() {
-    let mut a: Box<_> = box 1;
+    let mut a: Box<_> = Box::new(1);
     add(
         &*a,
         rewrite(&mut a)); //~ ERROR cannot borrow

src/test/ui/borrowck/borrowck-bad-nested-calls-move.rs

@@ -1,10 +1,10 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
-#![feature(box_syntax)]
+
 
 fn rewrite(v: &mut Box<usize>) -> usize {
-    *v = box 22;
+    *v = Box::new(22);
     **v
 }
 
@@ -13,7 +13,7 @@ fn add(v: &usize, w: Box<usize>) -> usize {
 }
 
 fn implicit() {
-    let mut a: Box<_> = box 1;
+    let mut a: Box<_> = Box::new(1);
 
     // Note the danger here:
     //
@@ -26,7 +26,7 @@ fn implicit() {
 }
 
 fn explicit() {
-    let mut a: Box<_> = box 1;
+    let mut a: Box<_> = Box::new(1);
     add(
         &*a,
         a); //~ ERROR cannot move

src/test/ui/borrowck/borrowck-borrow-from-expr-block.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 fn borrow<F>(x: &isize, f: F) where F: FnOnce(&isize) {
     f(x)
@@ -14,5 +13,5 @@ fn test1(x: &Box<isize>) {
 }
 
 pub fn main() {
-    test1(&box 22);
+    test1(&Box::new(22));
 }

src/test/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 struct A;
 
 impl A {
@@ -7,8 +5,10 @@ impl A {
     }
 }
 
+
+
 pub fn main() {
-    let a: Box<_> = box A;
+    let a: Box<_> = Box::new(A);
     a.foo();
     //~^ ERROR cannot borrow `*a` as mutable, as `a` is not declared as mutable [E0596]
 }

src/test/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr

@@ -1,7 +1,7 @@
 error[E0596]: cannot borrow `*a` as mutable, as `a` is not declared as mutable
   --> $DIR/borrowck-borrow-immut-deref-of-box-as-mut.rs:12:5
    |
-LL |     let a: Box<_> = box A;
+LL |     let a: Box<_> = Box::new(A);
    |         - help: consider changing this to be mutable: `mut a`
 LL |     a.foo();
    |     ^ cannot borrow as mutable

src/test/ui/borrowck/borrowck-borrowed-uniq-rvalue.rs

@@ -1,15 +1,15 @@
-//buggy.rs
-
-#![feature(box_syntax)]
-
 use std::collections::HashMap;
 
+
+
+
+
 fn main() {
     let tmp: Box<_>;
     let mut buggy_map: HashMap<usize, &usize> = HashMap::new();
     buggy_map.insert(42, &*Box::new(1)); //~ ERROR temporary value dropped while borrowed
 
     // but it is ok if we use a temporary
-    tmp = box 2;
+    tmp = Box::new(2);
     buggy_map.insert(43, &*tmp);
 }

src/test/ui/borrowck/borrowck-box-sensitivity.rs

@@ -3,8 +3,6 @@
 
 // run-pass
 
-#![feature(box_syntax)]
-
 struct A {
     x: Box<isize>,
     y: isize,
@@ -26,97 +24,97 @@ struct D {
 }
 
 fn copy_after_move() {
-    let a: Box<_> = box A { x: box 0, y: 1 };
+    let a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
     let _x = a.x;
     let _y = a.y;
 }
 
 fn move_after_move() {
-    let a: Box<_> = box B { x: box 0, y: box 1 };
+    let a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
     let _x = a.x;
     let _y = a.y;
 }
 
 fn borrow_after_move() {
-    let a: Box<_> = box A { x: box 0, y: 1 };
+    let a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
     let _x = a.x;
     let _y = &a.y;
 }
 
 fn move_after_borrow() {
-    let a: Box<_> = box B { x: box 0, y: box 1 };
+    let a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
     let _x = &a.x;
     let _y = a.y;
     use_imm(_x);
 }
 fn copy_after_mut_borrow() {
-    let mut a: Box<_> = box A { x: box 0, y: 1 };
+    let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
     let _x = &mut a.x;
     let _y = a.y;
     use_mut(_x);
 }
 fn move_after_mut_borrow() {
-    let mut a: Box<_> = box B { x: box 0, y: box 1 };
+    let mut a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
     let _x = &mut a.x;
     let _y = a.y;
     use_mut(_x);
 }
 fn borrow_after_mut_borrow() {
-    let mut a: Box<_> = box A { x: box 0, y: 1 };
+    let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
     let _x = &mut a.x;
     let _y = &a.y;
     use_mut(_x);
 }
 fn mut_borrow_after_borrow() {
-    let mut a: Box<_> = box A { x: box 0, y: 1 };
+    let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
     let _x = &a.x;
     let _y = &mut a.y;
     use_imm(_x);
 }
 fn copy_after_move_nested() {
-    let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
+    let a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
     let _x = a.x.x;
     let _y = a.y;
 }
 
 fn move_after_move_nested() {
-    let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
+    let a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
     let _x = a.x.x;
     let _y = a.y;
 }
 
 fn borrow_after_move_nested() {
-    let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
+    let a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
     let _x = a.x.x;
     let _y = &a.y;
 }
 
 fn move_after_borrow_nested() {
-    let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
+    let a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
     let _x = &a.x.x;
     let _y = a.y;
     use_imm(_x);
 }
 fn copy_after_mut_borrow_nested() {
-    let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
+    let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
     let _x = &mut a.x.x;
     let _y = a.y;
     use_mut(_x);
 }
 fn move_after_mut_borrow_nested() {
-    let mut a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
+    let mut a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
     let _x = &mut a.x.x;
     let _y = a.y;
     use_mut(_x);
 }
 fn borrow_after_mut_borrow_nested() {
-    let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
+    let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
     let _x = &mut a.x.x;
     let _y = &a.y;
     use_mut(_x);
 }
 fn mut_borrow_after_borrow_nested() {
-    let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
+    let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
     let _x = &a.x.x;
     let _y = &mut a.y;
     use_imm(_x);

src/test/ui/borrowck/borrowck-closures-mut-and-imm.rs

@@ -1,8 +1,6 @@
 // Tests that two closures cannot simultaneously have mutable
 // and immutable access to the variable. Issue #6801.
 
-#![feature(box_syntax)]
-
 fn get(x: &isize) -> isize {
     *x
 }
@@ -11,6 +9,8 @@ fn set(x: &mut isize) {
     *x = 4;
 }
 
+
+
 fn a() {
     let mut x = 3;
     let c1 = || x = 4;
@@ -52,7 +52,7 @@ fn e() {
 }
 
 fn f() {
-    let mut x: Box<_> = box 3;
+    let mut x: Box<_> = Box::new(3);
     let c1 = || get(&*x);
     *x = 5;
     //~^ ERROR cannot assign to `*x` because it is borrowed
@@ -64,7 +64,7 @@ fn g() {
         f: Box<isize>
     }
 
-    let mut x: Box<_> = box Foo { f: box 3 };
+    let mut x: Box<_> = Box::new(Foo { f: Box::new(3) });
     let c1 = || get(&*x.f);
     *x.f = 5;
     //~^ ERROR cannot assign to `*x.f` because it is borrowed
@@ -76,7 +76,7 @@ fn h() {
         f: Box<isize>
     }
 
-    let mut x: Box<_> = box Foo { f: box 3 };
+    let mut x: Box<_> = Box::new(Foo { f: Box::new(3) });
     let c1 = || get(&*x.f);
     let c2 = || *x.f = 5;
     //~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable

src/test/ui/borrowck/borrowck-closures-two-mut-fail.rs

@@ -2,7 +2,7 @@
 // access to the variable, whether that mutable access be used
 // for direct assignment or for taking mutable ref. Issue #6801.
 
-#![feature(box_syntax)]
+
 
 
 
@@ -48,7 +48,7 @@ fn g() {
         f: Box<isize>
     }
 
-    let mut x: Box<_> = box Foo { f: box 3 };
+    let mut x: Box<_> = Box::new(Foo { f: Box::new(3) });
     let c1 = to_fn_mut(|| set(&mut *x.f));
     let c2 = to_fn_mut(|| set(&mut *x.f));
     //~^ ERROR cannot borrow `x` as mutable more than once

src/test/ui/borrowck/borrowck-closures-two-mut.rs

@@ -2,7 +2,7 @@
 // access to the variable, whether that mutable access be used
 // for direct assignment or for taking mutable ref. Issue #6801.
 
-#![feature(box_syntax)]
+
 
 fn to_fn_mut<F: FnMut()>(f: F) -> F { f }
 
@@ -44,7 +44,7 @@ fn g() {
         f: Box<isize>
     }
 
-    let mut x: Box<_> = box Foo { f: box 3 };
+    let mut x: Box<_> = Box::new(Foo { f: Box::new(3) });
     let c1 = to_fn_mut(|| set(&mut *x.f));
     let c2 = to_fn_mut(|| set(&mut *x.f));
     //~^ ERROR cannot borrow `x` as mutable more than once

src/test/ui/borrowck/borrowck-closures-use-after-free.rs

@@ -2,8 +2,6 @@
 // cannot also be supplied a borrowed version of that
 // variable's contents. Issue #11192.
 
-#![feature(box_syntax)]
-
 struct Foo {
   x: isize
 }
@@ -14,10 +12,12 @@ impl Drop for Foo {
   }
 }
 
+
+
 fn main() {
-  let mut ptr: Box<_> = box Foo { x: 0 };
+  let mut ptr: Box<_> = Box::new(Foo { x: 0 });
   let mut test = |foo: &Foo| {
-    ptr = box Foo { x: ptr.x + 1 };
+    ptr = Box::new(Foo { x: ptr.x + 1 });
   };
   test(&*ptr); //~ ERROR cannot borrow `*ptr`
 }

src/test/ui/borrowck/borrowck-closures-use-after-free.stderr

@@ -3,7 +3,7 @@ error[E0502]: cannot borrow `*ptr` as immutable because it is also borrowed as m
    |
 LL |   let mut test = |foo: &Foo| {
    |                  ----------- mutable borrow occurs here
-LL |     ptr = box Foo { x: ptr.x + 1 };
+LL |     ptr = Box::new(Foo { x: ptr.x + 1 });
    |     --- first borrow occurs due to use of `ptr` in closure
 LL |   };
 LL |   test(&*ptr);

src/test/ui/borrowck/borrowck-field-sensitivity-rpass.rs

@@ -3,89 +3,87 @@
 #![allow(unused_variables)]
 // pretty-expanded FIXME #23616
 
-#![feature(box_syntax)]
-
 struct A { a: isize, b: Box<isize> }
 struct B { a: Box<isize>, b: Box<isize> }
 
 fn move_after_copy() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.a);
     drop(x.b);
 }
 
 fn move_after_fu_copy() {
-    let x = A { a: 1, b: box 2 };
-    let _y = A { b: box 3, .. x };
+    let x = A { a: 1, b: Box::new(2) };
+    let _y = A { b: Box::new(3), .. x };
     drop(x.b);
 }
 
 fn fu_move_after_copy() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.a);
     let _y = A { a: 3, .. x };
 }
 
 fn fu_move_after_fu_copy() {
-    let x = A { a: 1, b: box 2 };
-    let _y = A { b: box 3, .. x };
+    let x = A { a: 1, b: Box::new(2) };
+    let _y = A { b: Box::new(3), .. x };
     let _z = A { a: 4, .. x };
 }
 
 fn copy_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     drop(x.a);
 }
 
 fn copy_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let y = A { a: 3, .. x };
     drop(x.a);
 }
 
 fn fu_copy_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    let _y = A { b: box 3, .. x };
+    let _y = A { b: Box::new(3), .. x };
 }
 
 fn fu_copy_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    let _z = A { b: box 3, .. x };
+    let _z = A { b: Box::new(3), .. x };
 }
 
 fn borrow_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     let p = &x.a;
     drop(*p);
 }
 
 fn borrow_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
     let p = &x.a;
     drop(*p);
 }
 
 fn move_after_borrow() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let p = &x.a;
     drop(x.b);
     drop(*p);
 }
 
 fn fu_move_after_borrow() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let p = &x.a;
     let _y = A { a: 3, .. x };
     drop(*p);
 }
 
 fn mut_borrow_after_mut_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.a;
     let q = &mut x.b;
     drop(*p);
@@ -93,134 +91,134 @@ fn mut_borrow_after_mut_borrow() {
 }
 
 fn move_after_move() {
-    let x = B { a: box 1, b: box 2 };
+    let x = B { a: Box::new(1), b: Box::new(2) };
     drop(x.a);
     drop(x.b);
 }
 
 fn move_after_fu_move() {
-    let x = B { a: box 1, b: box 2 };
-    let y = B { a: box 3, .. x };
+    let x = B { a: Box::new(1), b: Box::new(2) };
+    let y = B { a: Box::new(3), .. x };
     drop(x.a);
 }
 
 fn fu_move_after_move() {
-    let x = B { a: box 1, b: box 2 };
+    let x = B { a: Box::new(1), b: Box::new(2) };
     drop(x.a);
-    let z = B { a: box 3, .. x };
+    let z = B { a: Box::new(3), .. x };
     drop(z.b);
 }
 
 fn fu_move_after_fu_move() {
-    let x = B { a: box 1, b: box 2 };
-    let _y = B { b: box 3, .. x };
-    let _z = B { a: box 4, .. x };
+    let x = B { a: Box::new(1), b: Box::new(2) };
+    let _y = B { b: Box::new(3), .. x };
+    let _z = B { a: Box::new(4), .. x };
 }
 
 fn copy_after_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     drop(*x.b);
 }
 
 fn copy_after_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     drop(*x.b);
 }
 
 fn copy_after_field_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    x.b = box 3;
+    x.b = Box::new(3);
     drop(*x.b);
 }
 
 fn copy_after_field_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x.b = box 3;
+    x.b = Box::new(3);
     drop(*x.b);
 }
 
 fn borrow_after_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     let p = &x.b;
     drop(**p);
 }
 
 fn borrow_after_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     let p = &x.b;
     drop(**p);
 }
 
 fn borrow_after_field_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    x.b = box 3;
+    x.b = Box::new(3);
     let p = &x.b;
     drop(**p);
 }
 
 fn borrow_after_field_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x.b = box 3;
+    x.b = Box::new(3);
     let p = &x.b;
     drop(**p);
 }
 
 fn move_after_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = x.b;
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     drop(x.b);
 }
 
 fn move_after_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x = A { a: 3, b: box 4 };
+    x = A { a: 3, b: Box::new(4) };
     drop(x.b);
 }
 
 fn move_after_field_assign_after_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     drop(x.b);
-    x.b = box 3;
+    x.b = Box::new(3);
     drop(x.b);
 }
 
 fn move_after_field_assign_after_fu_move() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
-    x.b = box 3;
+    x.b = Box::new(3);
     drop(x.b);
 }
 
 fn copy_after_assign_after_uninit() {
     let mut x: A;
-    x = A { a: 1, b: box 2 };
+    x = A { a: 1, b: Box::new(2) };
     drop(x.a);
 }
 
 fn borrow_after_assign_after_uninit() {
     let mut x: A;
-    x = A { a: 1, b: box 2 };
+    x = A { a: 1, b: Box::new(2) };
     let p = &x.a;
     drop(*p);
 }
 
 fn move_after_assign_after_uninit() {
     let mut x: A;
-    x = A { a: 1, b: box 2 };
+    x = A { a: 1, b: Box::new(2) };
     drop(x.b);
 }
 

src/test/ui/borrowck/borrowck-field-sensitivity.rs

@@ -1,49 +1,49 @@
-#![feature(box_syntax)]
-
 struct A { a: isize, b: Box<isize> }
 
+
+
 fn deref_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     drop(*x.b); //~ ERROR use of moved value: `x.b`
 }
 
 fn deref_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let y = A { a: 3, .. x };
     drop(*x.b); //~ ERROR use of moved value: `x.b`
 }
 
 fn borrow_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     let p = &x.b; //~ ERROR borrow of moved value: `x.b`
     drop(**p);
 }
 
 fn borrow_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
     let p = &x.b; //~ ERROR borrow of moved value: `x.b`
     drop(**p);
 }
 
 fn move_after_borrow() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let p = &x.b;
     drop(x.b); //~ ERROR cannot move out of `x.b` because it is borrowed
     drop(**p);
 }
 
 fn fu_move_after_borrow() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let p = &x.b;
     let _y = A { a: 3, .. x }; //~ ERROR cannot move out of `x.b` because it is borrowed
     drop(**p);
 }
 
 fn mut_borrow_after_mut_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.a;
     let q = &mut x.a; //~ ERROR cannot borrow `x.a` as mutable more than once at a time
     drop(*p);
@@ -51,25 +51,25 @@ fn mut_borrow_after_mut_borrow() {
 }
 
 fn move_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     drop(x.b);  //~ ERROR use of moved value: `x.b`
 }
 
 fn move_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
     drop(x.b);  //~ ERROR use of moved value: `x.b`
 }
 
 fn fu_move_after_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     drop(x.b);
     let _z = A { a: 3, .. x };  //~ ERROR use of moved value: `x.b`
 }
 
 fn fu_move_after_fu_move() {
-    let x = A { a: 1, b: box 2 };
+    let x = A { a: 1, b: Box::new(2) };
     let _y = A { a: 3, .. x };
     let _z = A { a: 4, .. x };  //~ ERROR use of moved value: `x.b`
 }
@@ -91,7 +91,7 @@ fn borrow_after_field_assign_after_uninit() {
 
 fn move_after_field_assign_after_uninit() {
     let mut x: A;
-    x.b = box 1; //~ ERROR assign to part of possibly-uninitialized variable: `x`
+    x.b = Box::new(1); //~ ERROR assign to part of possibly-uninitialized variable: `x`
     drop(x.b);
 }
 

src/test/ui/borrowck/borrowck-field-sensitivity.stderr

@@ -123,7 +123,7 @@ LL |     x.a = 1;
 error[E0381]: assign to part of possibly-uninitialized variable: `x`
   --> $DIR/borrowck-field-sensitivity.rs:94:5
    |
-LL |     x.b = box 1;
+LL |     x.b = Box::new(1);
    |     ^^^ use of possibly-uninitialized `x`
 
 error: aborting due to 14 previous errors

src/test/ui/borrowck/borrowck-for-loop-correct-cmt-for-pattern.rs

@@ -1,6 +1,6 @@
 // Issue #16205.
 
-#![feature(box_syntax)]
+
 
 struct Foo {
     a: [Box<isize>; 3],
@@ -13,12 +13,12 @@ fn main() {
     }
 
     let f = Foo {
-        a: [box 3, box 4, box 5],
+        a: [Box::new(3), Box::new(4), Box::new(5)],
     };
     for &a in &f.a {  //~ ERROR cannot move out
     }
 
-    let x: Option<Box<_>> = Some(box 1);
+    let x: Option<Box<_>> = Some(Box::new(1));
     for &a in x.iter() {    //~ ERROR cannot move out
     }
 }

src/test/ui/borrowck/borrowck-issue-14498.rs

@@ -4,14 +4,14 @@
 // Also includes tests of the errors reported when the Box in question
 // is immutable (#14270).
 
-#![feature(box_syntax)]
+
 
 struct A { a: isize }
 struct B<'a> { a: Box<&'a mut isize> }
 
 fn indirect_write_to_imm_box() {
     let mut x: isize = 1;
-    let y: Box<_> = box &mut x;
+    let y: Box<_> = Box::new(&mut x);
     let p = &y;
     ***p = 2; //~ ERROR cannot assign to `***p`
     drop(p);
@@ -19,7 +19,7 @@ fn indirect_write_to_imm_box() {
 
 fn borrow_in_var_from_var() {
     let mut x: isize = 1;
-    let mut y: Box<_> = box &mut x;
+    let mut y: Box<_> = Box::new(&mut x);
     let p = &y;
     let q = &***p;
     **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
@@ -29,7 +29,7 @@ fn borrow_in_var_from_var() {
 
 fn borrow_in_var_from_var_via_imm_box() {
     let mut x: isize = 1;
-    let y: Box<_> = box &mut x;
+    let y: Box<_> = Box::new(&mut x);
     let p = &y;
     let q = &***p;
     **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
@@ -39,7 +39,7 @@ fn borrow_in_var_from_var_via_imm_box() {
 
 fn borrow_in_var_from_field() {
     let mut x = A { a: 1 };
-    let mut y: Box<_> = box &mut x.a;
+    let mut y: Box<_> = Box::new(&mut x.a);
     let p = &y;
     let q = &***p;
     **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
@@ -49,7 +49,7 @@ fn borrow_in_var_from_field() {
 
 fn borrow_in_var_from_field_via_imm_box() {
     let mut x = A { a: 1 };
-    let y: Box<_> = box &mut x.a;
+    let y: Box<_> = Box::new(&mut x.a);
     let p = &y;
     let q = &***p;
     **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
@@ -59,7 +59,7 @@ fn borrow_in_var_from_field_via_imm_box() {
 
 fn borrow_in_field_from_var() {
     let mut x: isize = 1;
-    let mut y = B { a: box &mut x };
+    let mut y = B { a: Box::new(&mut x) };
     let p = &y.a;
     let q = &***p;
     **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
@@ -69,7 +69,7 @@ fn borrow_in_field_from_var() {
 
 fn borrow_in_field_from_var_via_imm_box() {
     let mut x: isize = 1;
-    let y = B { a: box &mut x };
+    let y = B { a: Box::new(&mut x) };
     let p = &y.a;
     let q = &***p;
     **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
@@ -79,7 +79,7 @@ fn borrow_in_field_from_var_via_imm_box() {
 
 fn borrow_in_field_from_field() {
     let mut x = A { a: 1 };
-    let mut y = B { a: box &mut x.a };
+    let mut y = B { a: Box::new(&mut x.a) };
     let p = &y.a;
     let q = &***p;
     **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
@@ -89,7 +89,7 @@ fn borrow_in_field_from_field() {
 
 fn borrow_in_field_from_field_via_imm_box() {
     let mut x = A { a: 1 };
-    let y = B { a: box &mut x.a };
+    let y = B { a: Box::new(&mut x.a) };
     let p = &y.a;
     let q = &***p;
     **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed

src/test/ui/borrowck/borrowck-issue-2657-1.rs

@@ -1,9 +1,9 @@
-#![feature(box_syntax)]
-
+trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { }  }
+impl<T> Fake for T { }
 
 
 fn main() {
-    let x: Option<Box<_>> = Some(box 1);
+    let x: Option<Box<_>> = Some(Box::new(1));
     match x {
       Some(ref _y) => {
         let _a = x; //~ ERROR cannot move
@@ -12,6 +12,3 @@ fn main() {
       _ => {}
     }
 }
-
-trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { }  }
-impl<T> Fake for T { }

src/test/ui/borrowck/borrowck-issue-2657-2.rs

@@ -1,7 +1,7 @@
-#![feature(box_syntax)]
-
 fn main() {
-    let x: Option<Box<_>> = Some(box 1);
+
+    let x: Option<Box<_>> = Some(Box::new(1));
+
     match x {
       Some(ref y) => {
         let _b = *y; //~ ERROR cannot move out

src/test/ui/borrowck/borrowck-lend-flow-if.rs

@@ -4,7 +4,7 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
-#![feature(box_syntax)]
+
 
 fn borrow(_v: &isize) {}
 fn borrow_mut(_v: &mut isize) {}
@@ -13,15 +13,15 @@ fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
 fn inc(v: &mut Box<isize>) {
-    *v = box (**v + 1);
+    *v = Box::new(**v + 1);
 }
 
 fn pre_freeze_cond() {
     // In this instance, the freeze is conditional and starts before
     // the mut borrow.
 
-    let u = box 0;
-    let mut v: Box<_> = box 3;
+    let u = Box::new(0);
+    let mut v: Box<_> = Box::new(3);
     let mut _w = &u;
     if cond() {
         _w = &v;
@@ -34,8 +34,8 @@ fn pre_freeze_else() {
     // In this instance, the freeze and mut borrow are on separate sides
     // of the if.
 
-    let u = box 0;
-    let mut v: Box<_> = box 3;
+    let u = Box::new(0);
+    let mut v: Box<_> = Box::new(3);
     let mut _w = &u;
     if cond() {
         _w = &v;

src/test/ui/borrowck/borrowck-lend-flow-loop.rs

@@ -1,18 +1,18 @@
-#![feature(box_syntax)]
-
 fn borrow(_v: &isize) {}
 fn borrow_mut(_v: &mut isize) {}
 fn cond() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
+
 fn inc(v: &mut Box<isize>) {
-    *v = box (**v + 1);
+    *v = Box::new(**v + 1);
 }
 
+
 fn loop_overarching_alias_mut() {
     // In this instance, the borrow ends on the line before the loop
 
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     let mut x = &mut v;
     **x += 1;
     loop {
@@ -23,18 +23,18 @@ fn loop_overarching_alias_mut() {
 fn block_overarching_alias_mut() {
     // In this instance, the borrow encompasses the entire closure call.
 
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     let mut x = &mut v;
     for _ in 0..3 {
         borrow(&*v); //~ ERROR cannot borrow
     }
-    *x = box 5;
+    *x = Box::new(5);
 }
 fn loop_aliased_mut() {
     // In this instance, the borrow ends right after each assignment to _x
 
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut _x = &w;
     loop {
         borrow_mut(&mut *v); // OK
@@ -45,8 +45,8 @@ fn loop_aliased_mut() {
 fn while_aliased_mut() {
     // In this instance, the borrow ends right after each assignment to _x
 
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut _x = &w;
     while cond() {
         borrow_mut(&mut *v); // OK
@@ -58,8 +58,8 @@ fn while_aliased_mut() {
 fn loop_aliased_mut_break() {
     // In this instance, the borrow ends right after each assignment to _x
 
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut _x = &w;
     loop {
         borrow_mut(&mut *v);
@@ -72,8 +72,8 @@ fn loop_aliased_mut_break() {
 fn while_aliased_mut_break() {
     // In this instance, the borrow ends right after each assignment to _x
 
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut _x = &w;
     while cond() {
         borrow_mut(&mut *v);
@@ -84,8 +84,8 @@ fn while_aliased_mut_break() {
 }
 
 fn while_aliased_mut_cond(cond: bool, cond2: bool) {
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut x = &mut w;
     while cond {
         **x += 1;

src/test/ui/borrowck/borrowck-lend-flow-loop.stderr

@@ -7,7 +7,7 @@ LL |     for _ in 0..3 {
 LL |         borrow(&*v);
    |                ^^^ immutable borrow occurs here
 LL |     }
-LL |     *x = box 5;
+LL |     *x = Box::new(5);
    |     -- mutable borrow later used here
 
 error[E0502]: cannot borrow `*v` as immutable because it is also borrowed as mutable

src/test/ui/borrowck/borrowck-lend-flow.rs

@@ -4,7 +4,7 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
-#![feature(box_syntax)]
+
 
 fn borrow(_v: &isize) {}
 fn borrow_mut(_v: &mut isize) {}
@@ -13,13 +13,13 @@ fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
 fn inc(v: &mut Box<isize>) {
-    *v = box (**v + 1);
+    *v = Box::new(**v + 1);
 }
 
 fn pre_freeze() {
     // In this instance, the freeze starts before the mut borrow.
 
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     let _w = &v;
     borrow_mut(&mut *v); //~ ERROR cannot borrow
     _w.use_ref();
@@ -28,7 +28,7 @@ fn pre_freeze() {
 fn post_freeze() {
     // In this instance, the const alias starts after the borrow.
 
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     borrow_mut(&mut *v);
     let _w = &v;
 }

src/test/ui/borrowck/borrowck-loan-blocks-move-cc.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 use std::thread;
 
 
@@ -8,8 +6,10 @@ fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
     f(v);
 }
 
+
+
 fn box_imm() {
-    let v: Box<_> = box 3;
+    let v: Box<_> = Box::new(3);
     let w = &v;
     thread::spawn(move|| {
     //~^ ERROR cannot move out of `v` because it is borrowed
@@ -19,7 +19,7 @@ fn box_imm() {
 }
 
 fn box_imm_explicit() {
-    let v: Box<_> = box 3;
+    let v: Box<_> = Box::new(3);
     let w = &v;
     thread::spawn(move|| {
     //~^ ERROR cannot move

src/test/ui/borrowck/borrowck-loan-blocks-move.rs

@@ -1,12 +1,12 @@
-#![feature(box_syntax)]
-
-
-
 fn take(_v: Box<isize>) {
 }
 
+
+
+
+
 fn box_imm() {
-    let v = box 3;
+    let v = Box::new(3);
     let w = &v;
     take(v); //~ ERROR cannot move out of `v` because it is borrowed
     w.use_ref();

src/test/ui/borrowck/borrowck-loan-blocks-mut-uniq.rs

@@ -1,14 +1,14 @@
-#![feature(box_syntax)]
-
 fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
     f(v);
 }
 
+
+
 fn box_imm() {
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     borrow(&*v,
            |w| { //~ ERROR cannot borrow `v` as mutable
-            v = box 4;
+            v = Box::new(4);
             assert_eq!(*v, 3);
             assert_eq!(*w, 4);
         })

src/test/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr

@@ -7,7 +7,7 @@ LL |     borrow(&*v,
    |     immutable borrow later used by call
 LL |            |w| {
    |            ^^^ mutable borrow occurs here
-LL |             v = box 4;
+LL |             v = Box::new(4);
    |             - second borrow occurs due to use of `v` in closure
 
 error: aborting due to previous error

src/test/ui/borrowck/borrowck-loan-in-overloaded-op.rs

@@ -1,5 +1,5 @@
 #![feature(box_patterns)]
-#![feature(box_syntax)]
+
 
 use std::ops::Add;
 
@@ -12,12 +12,12 @@ impl Add for Foo {
     fn add(self, f: Foo) -> Foo {
         let Foo(box i) = self;
         let Foo(box j) = f;
-        Foo(box (i + j))
+        Foo(Box::new(i + j))
     }
 }
 
 fn main() {
-    let x = Foo(box 3);
+    let x = Foo(Box::new(3));
     let _y = {x} + x.clone(); // the `{x}` forces a move to occur
     //~^ ERROR borrow of moved value: `x`
 }

src/test/ui/borrowck/borrowck-loan-in-overloaded-op.stderr

@@ -1,7 +1,7 @@
 error[E0382]: borrow of moved value: `x`
   --> $DIR/borrowck-loan-in-overloaded-op.rs:21:20
    |
-LL |     let x = Foo(box 3);
+LL |     let x = Foo(Box::new(3));
    |         - move occurs because `x` has type `Foo`, which does not implement the `Copy` trait
 LL |     let _y = {x} + x.clone(); // the `{x}` forces a move to occur
    |               -    ^ value borrowed here after move

src/test/ui/borrowck/borrowck-macro-interaction-issue-6304.rs

@@ -6,9 +6,7 @@
 // Check that we do not ICE when compiling this
 // macro, which reuses the expression `$id`
 
-
 #![feature(box_patterns)]
-#![feature(box_syntax)]
 
 struct Foo {
   a: isize
@@ -23,7 +21,7 @@ impl Foo {
     macro_rules! declare {
       ($id:expr, $rest:expr) => ({
         self.check_id($id);
-        box Bar::Bar2($id, $rest)
+        Box::new(Bar::Bar2($id, $rest))
       })
     }
     match s {

src/test/ui/borrowck/borrowck-move-by-capture-ok.rs

@@ -1,8 +1,7 @@
 // run-pass
-#![feature(box_syntax)]
 
 pub fn main() {
-    let bar: Box<_> = box 3;
+    let bar: Box<_> = Box::new(3);
     let h = || -> isize { *bar };
     assert_eq!(h(), 3);
 }

src/test/ui/borrowck/borrowck-move-by-capture.rs

@@ -1,10 +1,10 @@
-#![feature(box_syntax,unboxed_closures)]
+#![feature(unboxed_closures)]
 
 fn to_fn_mut<A,F:FnMut<A>>(f: F) -> F { f }
 fn to_fn_once<A,F:FnOnce<A>>(f: F) -> F { f }
 
 pub fn main() {
-    let bar: Box<_> = box 3;
+    let bar: Box<_> = Box::new(3);
     let _g = to_fn_mut(|| {
         let _h = to_fn_once(move || -> isize { *bar }); //~ ERROR cannot move out of
     });

src/test/ui/borrowck/borrowck-move-by-capture.stderr

@@ -1,7 +1,7 @@
 error[E0507]: cannot move out of `bar`, a captured variable in an `FnMut` closure
   --> $DIR/borrowck-move-by-capture.rs:9:29
    |
-LL |       let bar: Box<_> = box 3;
+LL |       let bar: Box<_> = Box::new(3);
    |           --- captured outer variable
 LL |       let _g = to_fn_mut(|| {
    |  ________________________-

src/test/ui/borrowck/borrowck-move-error-with-note.rs

@@ -1,13 +1,13 @@
-#![feature(box_syntax)]
-
 enum Foo {
     Foo1(Box<u32>, Box<u32>),
     Foo2(Box<u32>),
     Foo3,
 }
 
+
+
 fn blah() {
-    let f = &Foo::Foo1(box 1, box 2);
+    let f = &Foo::Foo1(Box::new(1), Box::new(2));
     match *f { //~ ERROR cannot move out of
         Foo::Foo1(num1,
                   num2) => (),
@@ -42,7 +42,7 @@ struct A {
 fn free<T>(_: T) {}
 
 fn blah2() {
-    let a = &A { a: box 1 };
+    let a = &A { a: Box::new(1) };
     match a.a { //~ ERROR cannot move out of
         n => {
             free(n)

src/test/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.rs

@@ -3,10 +3,10 @@
 
 
 
-#![feature(box_syntax)]
+
 
 fn main() {
-    let a: Box<Box<_>> = box box 2;
+    let a: Box<Box<_>> = Box::new(Box::new(2));
     let b = &a;
 
     let z = *a; //~ ERROR: cannot move out of `*a` because it is borrowed

src/test/ui/borrowck/borrowck-move-moved-value-into-closure.rs

@@ -1,11 +1,11 @@
-#![feature(box_syntax)]
-
 fn call_f<F:FnOnce() -> isize>(f: F) -> isize {
     f()
 }
 
+
+
 fn main() {
-    let t: Box<_> = box 3;
+    let t: Box<_> = Box::new(3);
 
     call_f(move|| { *t + 1 });
     call_f(move|| { *t + 1 }); //~ ERROR use of moved value

src/test/ui/borrowck/borrowck-move-moved-value-into-closure.stderr

@@ -1,7 +1,7 @@
 error[E0382]: use of moved value: `t`
   --> $DIR/borrowck-move-moved-value-into-closure.rs:11:12
    |
-LL |     let t: Box<_> = box 3;
+LL |     let t: Box<_> = Box::new(3);
    |         - move occurs because `t` has type `Box<isize>`, which does not implement the `Copy` trait
 LL | 
 LL |     call_f(move|| { *t + 1 });

src/test/ui/borrowck/borrowck-move-subcomponent.rs

@@ -1,7 +1,7 @@
 // Tests that the borrow checker checks all components of a path when moving
 // out.
 
-#![feature(box_syntax)]
+
 
 struct S {
   x : Box<isize>
@@ -10,7 +10,7 @@ struct S {
 fn f<T>(_: T) {}
 
 fn main() {
-  let a : S = S { x : box 1 };
+  let a : S = S { x : Box::new(1) };
   let pb = &a;
   let S { x: ax } = a;  //~ ERROR cannot move out
   f(pb);

src/test/ui/borrowck/borrowck-multiple-captures.rs

@@ -1,13 +1,13 @@
-#![feature(box_syntax)]
-
 use std::thread;
 
+
 fn borrow<T>(_: &T) { }
 
+
 fn different_vars_after_borrows() {
-    let x1: Box<_> = box 1;
+    let x1: Box<_> = Box::new(1);
     let p1 = &x1;
-    let x2: Box<_> = box 2;
+    let x2: Box<_> = Box::new(2);
     let p2 = &x2;
     thread::spawn(move|| {
         //~^ ERROR cannot move out of `x1` because it is borrowed
@@ -20,9 +20,9 @@ fn different_vars_after_borrows() {
 }
 
 fn different_vars_after_moves() {
-    let x1: Box<_> = box 1;
+    let x1: Box<_> = Box::new(1);
     drop(x1);
-    let x2: Box<_> = box 2;
+    let x2: Box<_> = Box::new(2);
     drop(x2);
     thread::spawn(move|| {
         //~^ ERROR use of moved value: `x1`
@@ -33,7 +33,7 @@ fn different_vars_after_moves() {
 }
 
 fn same_var_after_borrow() {
-    let x: Box<_> = box 1;
+    let x: Box<_> = Box::new(1);
     let p = &x;
     thread::spawn(move|| {
         //~^ ERROR cannot move out of `x` because it is borrowed
@@ -44,7 +44,7 @@ fn same_var_after_borrow() {
 }
 
 fn same_var_after_move() {
-    let x: Box<_> = box 1;
+    let x: Box<_> = Box::new(1);
     drop(x);
     thread::spawn(move|| {
         //~^ ERROR use of moved value: `x`

src/test/ui/borrowck/borrowck-multiple-captures.stderr

@@ -30,7 +30,7 @@ LL |     borrow(&*p2);
 error[E0382]: use of moved value: `x1`
   --> $DIR/borrowck-multiple-captures.rs:27:19
    |
-LL |     let x1: Box<_> = box 1;
+LL |     let x1: Box<_> = Box::new(1);
    |         -- move occurs because `x1` has type `Box<i32>`, which does not implement the `Copy` trait
 LL |     drop(x1);
    |          -- value moved here
@@ -44,7 +44,7 @@ LL |         drop(x1);
 error[E0382]: use of moved value: `x2`
   --> $DIR/borrowck-multiple-captures.rs:27:19
    |
-LL |     let x2: Box<_> = box 2;
+LL |     let x2: Box<_> = Box::new(2);
    |         -- move occurs because `x2` has type `Box<i32>`, which does not implement the `Copy` trait
 LL |     drop(x2);
    |          -- value moved here
@@ -91,7 +91,7 @@ LL |         drop(x);
 error[E0382]: use of moved value: `x`
   --> $DIR/borrowck-multiple-captures.rs:49:19
    |
-LL |     let x: Box<_> = box 1;
+LL |     let x: Box<_> = Box::new(1);
    |         - move occurs because `x` has type `Box<i32>`, which does not implement the `Copy` trait
 LL |     drop(x);
    |          - value moved here

src/test/ui/borrowck/borrowck-mut-uniq.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(box_syntax)]
 
 use std::mem::swap;
 
@@ -20,7 +19,7 @@ fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&isize) -> bool {
 }
 
 pub fn main() {
-    let mut ints: Box<_> = box Ints {sum: box 0, values: Vec::new()};
+    let mut ints: Box<_> = Box::new(Ints {sum: Box::new(0), values: Vec::new()});
     add_int(&mut *ints, 22);
     add_int(&mut *ints, 44);
 

src/test/ui/borrowck/borrowck-no-cycle-in-exchange-heap.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 struct Node_ {
     a: Box<Cycle>
 }
@@ -8,8 +6,10 @@ enum Cycle {
     Node(Node_),
     Empty,
 }
+
 fn main() {
-    let mut x: Box<_> = box Cycle::Node(Node_ {a: box Cycle::Empty});
+    let mut x: Box<_> = Box::new(Cycle::Node(Node_ {a: Box::new(Cycle::Empty)}));
+
     // Create a cycle!
     match *x {
       Cycle::Node(ref mut y) => {

src/test/ui/borrowck/borrowck-overloaded-index-move-from-vec.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 use std::ops::Index;
 
 struct MyVec<T> {
@@ -14,8 +12,10 @@ impl<T> Index<usize> for MyVec<T> {
     }
 }
 
+
+
 fn main() {
-    let v = MyVec::<Box<_>> { data: vec![box 1, box 2, box 3] };
+    let v = MyVec::<Box<_>> { data: vec![Box::new(1), Box::new(2), Box::new(3)] };
     let good = &v[0]; // Shouldn't fail here
     let bad = v[0];
     //~^ ERROR cannot move out of index of `MyVec<Box<i32>>`

src/test/ui/borrowck/borrowck-uniq-via-lend.rs

@@ -1,17 +1,17 @@
-#![feature(box_syntax)]
-
-
-
 fn borrow(_v: &isize) {}
 
+
+
+
+
 fn local() {
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     borrow(&*v);
 }
 
 fn local_rec() {
     struct F { f: Box<isize> }
-    let mut v = F {f: box 3};
+    let mut v = F {f: Box::new(3)};
     borrow(&*v.f);
 }
 
@@ -19,35 +19,35 @@ fn local_recs() {
     struct F { f: G }
     struct G { g: H }
     struct H { h: Box<isize> }
-    let mut v = F {f: G {g: H {h: box 3}}};
+    let mut v = F {f: G {g: H {h: Box::new(3)}}};
     borrow(&*v.f.g.h);
 }
 
 fn aliased_imm() {
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     let w = &v;
     borrow(&*v);
     w.use_ref();
 }
 
 fn aliased_mut() {
-    let mut v: Box<_> = box 3;
+    let mut v: Box<_> = Box::new(3);
     let w = &mut v;
     borrow(&*v); //~ ERROR cannot borrow `*v`
     w.use_mut();
 }
 
 fn aliased_other() {
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let x = &mut w;
     borrow(&*v);
     x.use_mut();
 }
 
 fn aliased_other_reassign() {
-    let mut v: Box<_> = box 3;
-    let mut w: Box<_> = box 4;
+    let mut v: Box<_> = Box::new(3);
+    let mut w: Box<_> = Box::new(4);
     let mut x = &mut w;
     x = &mut v;
     borrow(&*v); //~ ERROR cannot borrow `*v`

src/test/ui/borrowck/borrowck-use-mut-borrow-rpass.rs

@@ -1,41 +1,39 @@
 // run-pass
 // pretty-expanded FIXME #23616
 
-#![feature(box_syntax)]
-
 struct A { a: isize, b: Box<isize> }
 
 fn field_copy_after_field_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.b;
     drop(x.a);
     **p = 3;
 }
 
 fn fu_field_copy_after_field_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.b;
-    let y = A { b: box 3, .. x };
+    let y = A { b: Box::new(3), .. x };
     drop(y);
     **p = 4;
 }
 
 fn field_deref_after_field_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.a;
     drop(*x.b);
     *p = 3;
 }
 
 fn field_move_after_field_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.a;
     drop(x.b);
     *p = 3;
 }
 
 fn fu_field_move_after_field_borrow() {
-    let mut x = A { a: 1, b: box 2 };
+    let mut x = A { a: 1, b: Box::new(2) };
     let p = &mut x.a;
     let y = A { a: 3, .. x };
     drop(y);

src/test/ui/borrowck/borrowck-use-mut-borrow.rs

@@ -1,10 +1,10 @@
-#![feature(box_syntax)]
-
 #[derive(Copy, Clone)]
 struct A { a: isize, b: isize }
 
 struct B { a: isize, b: Box<isize> }
 
+
+
 fn var_copy_after_var_borrow() {
     let mut x: isize = 1;
     let p = &mut x;
@@ -50,21 +50,21 @@ fn fu_field_copy_after_field_borrow() {
 }
 
 fn var_deref_after_var_borrow() {
-    let mut x: Box<isize> = box 1;
+    let mut x: Box<isize> = Box::new(1);
     let p = &mut x;
     drop(*x); //~ ERROR cannot use `*x` because it was mutably borrowed
     **p = 2;
 }
 
 fn field_deref_after_var_borrow() {
-    let mut x = B { a: 1, b: box 2 };
+    let mut x = B { a: 1, b: Box::new(2) };
     let p = &mut x;
     drop(*x.b); //~ ERROR cannot use `*x.b` because it was mutably borrowed
     p.a = 3;
 }
 
 fn field_deref_after_field_borrow() {
-    let mut x = B { a: 1, b: box 2 };
+    let mut x = B { a: 1, b: Box::new(2) };
     let p = &mut x.b;
     drop(*x.b); //~ ERROR cannot use `*x.b` because it was mutably borrowed
     **p = 3;

src/test/ui/borrowck/borrowck-vec-pattern-nesting.rs

@@ -1,12 +1,12 @@
 #![feature(box_patterns)]
-#![feature(box_syntax)]
+
 
 fn a() {
-    let mut vec = [box 1, box 2, box 3];
+    let mut vec = [Box::new(1), Box::new(2), Box::new(3)];
     match vec {
         [box ref _a, _, _] => {
         //~^ NOTE borrow of `vec[_]` occurs here
-            vec[0] = box 4; //~ ERROR cannot assign
+            vec[0] = Box::new(4); //~ ERROR cannot assign
             //~^ NOTE assignment to borrowed `vec[_]` occurs here
             _a.use_ref();
             //~^ NOTE borrow later used here
@@ -15,12 +15,12 @@ fn a() {
 }
 
 fn b() {
-    let mut vec = vec![box 1, box 2, box 3];
+    let mut vec = vec![Box::new(1), Box::new(2), Box::new(3)];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         &mut [ref _b @ ..] => {
         //~^ borrow of `vec[_]` occurs here
-            vec[0] = box 4; //~ ERROR cannot assign
+            vec[0] = Box::new(4); //~ ERROR cannot assign
             //~^ NOTE assignment to borrowed `vec[_]` occurs here
             _b.use_ref();
             //~^ NOTE borrow later used here
@@ -29,7 +29,7 @@ fn b() {
 }
 
 fn c() {
-    let mut vec = vec![box 1, box 2, box 3];
+    let mut vec = vec![Box::new(1), Box::new(2), Box::new(3)];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         //~^ ERROR cannot move out
@@ -50,7 +50,7 @@ fn c() {
 }
 
 fn d() {
-    let mut vec = vec![box 1, box 2, box 3];
+    let mut vec = vec![Box::new(1), Box::new(2), Box::new(3)];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         //~^ ERROR cannot move out
@@ -69,7 +69,7 @@ fn d() {
 }
 
 fn e() {
-    let mut vec = vec![box 1, box 2, box 3];
+    let mut vec = vec![Box::new(1), Box::new(2), Box::new(3)];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         //~^ ERROR cannot move out