rustc: Obsolete the `@` syntax entirely

This removes all remnants of `@` pointers from rustc. Additionally, this removes
the `GC` structure from the prelude as it seems odd exporting an experimental
type in the prelude by default.

Closes #14193
[breaking-change]

12 files changed, 60 insertions, 39 deletions

diff --git a/src/test/debuginfo/borrowed-managed-basic.rs b/src/test/debuginfo/borrowed-managed-basic.rs
index 85f32585905..0f81e530fdd 100644
--- a/src/test/debuginfo/borrowed-managed-basic.rs
+++ b/src/test/debuginfo/borrowed-managed-basic.rs
@@ -63,47 +63,49 @@
 
 #![allow(unused_variable)]
 
+use std::gc::{Gc, GC};
+
 fn main() {
-    let bool_box: @bool = @true;
+    let bool_box: Gc<bool> = box(GC) true;
     let bool_ref: &bool = bool_box;
 
-    let int_box: @int = @-1;
+    let int_box: Gc<int> = box(GC) -1;
     let int_ref: &int = int_box;
 
-    let char_box: @char = @'a';
+    let char_box: Gc<char> = box(GC) 'a';
     let char_ref: &char = char_box;
 
-    let i8_box: @i8 = @68;
+    let i8_box: Gc<i8> = box(GC) 68;
     let i8_ref: &i8 = i8_box;
 
-    let i16_box: @i16 = @-16;
+    let i16_box: Gc<i16> = box(GC) -16;
     let i16_ref: &i16 = i16_box;
 
-    let i32_box: @i32 = @-32;
+    let i32_box: Gc<i32> = box(GC) -32;
     let i32_ref: &i32 = i32_box;
 
-    let i64_box: @i64 = @-64;
+    let i64_box: Gc<i64> = box(GC) -64;
     let i64_ref: &i64 = i64_box;
 
-    let uint_box: @uint = @1;
+    let uint_box: Gc<uint> = box(GC) 1;
     let uint_ref: &uint = uint_box;
 
-    let u8_box: @u8 = @100;
+    let u8_box: Gc<u8> = box(GC) 100;
     let u8_ref: &u8 = u8_box;
 
-    let u16_box: @u16 = @16;
+    let u16_box: Gc<u16> = box(GC) 16;
     let u16_ref: &u16 = u16_box;
 
-    let u32_box: @u32 = @32;
+    let u32_box: Gc<u32> = box(GC) 32;
     let u32_ref: &u32 = u32_box;
 
-    let u64_box: @u64 = @64;
+    let u64_box: Gc<u64> = box(GC) 64;
     let u64_ref: &u64 = u64_box;
 
-    let f32_box: @f32 = @2.5;
+    let f32_box: Gc<f32> = box(GC) 2.5;
     let f32_ref: &f32 = f32_box;
 
-    let f64_box: @f64 = @3.5;
+    let f64_box: Gc<f64> = box(GC) 3.5;
     let f64_ref: &f64 = f64_box;
     zzz();
 }
diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs
index 8ac0745513d..98b66098862 100644
--- a/src/test/debuginfo/borrowed-struct.rs
+++ b/src/test/debuginfo/borrowed-struct.rs
@@ -48,6 +48,8 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+use std::gc::GC;
+
 struct SomeStruct {
     x: int,
     y: f64
@@ -60,7 +62,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 managed_val = @SomeStruct { x: 12, y: 25.5 };
+    let managed_val = box(GC) SomeStruct { x: 12, y: 25.5 };
     let managed_val_ref: &SomeStruct = managed_val;
     let managed_val_interior_ref_1: &int = &managed_val.x;
     let managed_val_interior_ref_2: &f64 = &managed_val.y;
diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs
index 427981445c1..b88161e4a0b 100644
--- a/src/test/debuginfo/borrowed-tuple.rs
+++ b/src/test/debuginfo/borrowed-tuple.rs
@@ -31,13 +31,14 @@
 
 #![allow(unused_variable)]
 
+use std::gc::{Gc, GC};
 
 fn main() {
     let stack_val: (i16, f32) = (-14, -19f32);
     let stack_val_ref: &(i16, f32) = &stack_val;
     let ref_to_unnamed: &(i16, f32) = &(-15, -20f32);
 
-    let managed_val: @(i16, f32) = @(-16, -21f32);
+    let managed_val: Gc<(i16, f32)> = box(GC) (-16, -21f32);
     let managed_val_ref: &(i16, f32) = managed_val;
 
     let unique_val: Box<(i16, f32)> = box() (-17, -22f32);
diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs
index c29d3d88378..01129c845e9 100644
--- a/src/test/debuginfo/box.rs
+++ b/src/test/debuginfo/box.rs
@@ -27,11 +27,13 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+use std::gc::GC;
+
 fn main() {
     let a = box 1;
     let b = box() (2, 3.5);
-    let c = @4;
-    let d = @false;
+    let c = box(GC) 4;
+    let d = box(GC) false;
     _zzz();
 }
 
diff --git a/src/test/debuginfo/boxed-struct.rs b/src/test/debuginfo/boxed-struct.rs
index 1c94885adaf..f583016b93f 100644
--- a/src/test/debuginfo/boxed-struct.rs
+++ b/src/test/debuginfo/boxed-struct.rs
@@ -30,6 +30,7 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+use std::gc::GC;
 
 struct StructWithSomePadding {
     x: i16,
@@ -52,10 +53,10 @@ impl Drop for StructWithDestructor {
 fn main() {
 
     let unique = box StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 };
-    let managed = @StructWithSomePadding { x: 88, y: 888, z: 8888, w: 88888 };
+    let managed = box(GC) StructWithSomePadding { x: 88, y: 888, z: 8888, w: 88888 };
 
     let unique_dtor = box StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 };
-    let managed_dtor = @StructWithDestructor { x: 33, y: 333, z: 3333, w: 33333 };
+    let managed_dtor = box(GC) StructWithDestructor { x: 33, y: 333, z: 3333, w: 33333 };
 
     zzz();
 }
diff --git a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
index b626fbad278..0da2d44d5ae 100644
--- a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -36,6 +36,8 @@
 // gdb-check:$4 = 8888
 // gdb-command:continue
 
+use std::gc::{Gc, GC};
+
 trait Trait {
     fn method(self) -> Self;
 }
@@ -66,8 +68,8 @@ impl Trait for (f64, int, int, f64) {
     }
 }
 
-impl Trait for @int {
-    fn method(self) -> @int {
+impl Trait for Gc<int> {
+    fn method(self) -> Gc<int> {
         zzz();
         self
     }
@@ -77,7 +79,7 @@ fn main() {
     let _ = (1111 as int).method();
     let _ = Struct { x: 2222, y: 3333 }.method();
     let _ = (4444.5, 5555, 6666, 7777.5).method();
-    let _ = (@8888).method();
+    let _ = (box(GC) 8888).method();
 }
 
 fn zzz() {()}
diff --git a/src/test/debuginfo/managed-enum.rs b/src/test/debuginfo/managed-enum.rs
index 36e75812deb..bb236a28a88 100644
--- a/src/test/debuginfo/managed-enum.rs
+++ b/src/test/debuginfo/managed-enum.rs
@@ -27,6 +27,8 @@
 #![allow(unused_variable)]
 #![feature(struct_variant, managed_boxes)]
 
+use std::gc::GC;
+
 // The first element is to ensure proper alignment, irrespective of the machines word size. Since
 // the size of the discriminant value is machine dependent, this has be taken into account when
 // datatype layout should be predictable as in this case.
@@ -50,15 +52,15 @@ fn main() {
     // 0b01111100011111000111110001111100 = 2088533116
     // 0b0111110001111100 = 31868
     // 0b01111100 = 124
-    let the_a = @TheA { x: 0, y: 8970181431921507452 };
+    let the_a = box(GC) TheA { x: 0, y: 8970181431921507452 };
 
     // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
     // 0b00010001000100010001000100010001 = 286331153
     // 0b0001000100010001 = 4369
     // 0b00010001 = 17
-    let the_b = @TheB (0, 286331153, 286331153);
+    let the_b = box(GC) TheB (0, 286331153, 286331153);
 
-    let univariant = @TheOnlyCase(-9747455);
+    let univariant = box(GC) TheOnlyCase(-9747455);
 
     zzz();
 }
diff --git a/src/test/debuginfo/managed-pointer-within-unique-vec.rs b/src/test/debuginfo/managed-pointer-within-unique-vec.rs
index a2a0d171898..d1f38be1d89 100644
--- a/src/test/debuginfo/managed-pointer-within-unique-vec.rs
+++ b/src/test/debuginfo/managed-pointer-within-unique-vec.rs
@@ -31,9 +31,11 @@
 
 #![allow(unused_variable)]
 
+use std::gc::{Gc, GC};
+
 fn main() {
 
-    let unique: Vec<@i64> = vec!(@10, @11, @12, @13);
+    let unique: Vec<Gc<i64>> = vec!(box(GC) 10, box(GC) 11, box(GC) 12, box(GC) 13);
 
     zzz();
 }
diff --git a/src/test/debuginfo/managed-pointer-within-unique.rs b/src/test/debuginfo/managed-pointer-within-unique.rs
index be2cc696d4f..b56db2d1846 100644
--- a/src/test/debuginfo/managed-pointer-within-unique.rs
+++ b/src/test/debuginfo/managed-pointer-within-unique.rs
@@ -29,15 +29,17 @@
 
 #![allow(unused_variable)]
 
+use std::gc::{GC, Gc};
+
 struct ContainsManaged {
     x: int,
-    y: @int
+    y: Gc<int>,
 }
 
 fn main() {
     let ordinary_unique = box() (-1, -2);
 
-    let managed_within_unique = box ContainsManaged { x: -3, y: @-4 };
+    let managed_within_unique = box ContainsManaged { x: -3, y: box(GC) -4 };
 
     zzz();
 }
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index 518ef62fe9a..ea0867903b5 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -106,6 +106,7 @@
 #![allow(unused_variable)]
 #![feature(struct_variant)]
 
+use std::gc::{Gc, GC};
 
 enum Opt<T> {
     Empty,
@@ -118,7 +119,7 @@ struct UniqueNode<T> {
 }
 
 struct ManagedNode<T> {
-    next: Opt<@ManagedNode<T>>,
+    next: Opt<Gc<ManagedNode<T>>>,
     value: T
 }
 
@@ -183,7 +184,7 @@ fn main() {
         value: 2,
     };
 
-    let box_unique: @UniqueNode<u64> = @UniqueNode {
+    let box_unique: Gc<UniqueNode<u64>> = box(GC) UniqueNode {
         next: Val {
             val: box UniqueNode {
                 next: Empty,
@@ -215,7 +216,7 @@ fn main() {
 
     let stack_managed: ManagedNode<u16> = ManagedNode {
         next: Val {
-            val: @ManagedNode {
+            val: box(GC) ManagedNode {
                 next: Empty,
                 value: 11,
             }
@@ -225,7 +226,7 @@ fn main() {
 
     let unique_managed: Box<ManagedNode<u32>> = box ManagedNode {
         next: Val {
-            val: @ManagedNode {
+            val: box(GC) ManagedNode {
                 next: Empty,
                 value: 13,
             }
@@ -233,9 +234,9 @@ fn main() {
         value: 12,
     };
 
-    let box_managed: @ManagedNode<u64> = @ManagedNode {
+    let box_managed: Gc<ManagedNode<u64>> = box(GC) ManagedNode {
         next: Val {
-            val: @ManagedNode {
+            val: box(GC) ManagedNode {
                 next: Empty,
                 value: 15,
             }
@@ -245,7 +246,7 @@ fn main() {
 
     let vec_managed: [ManagedNode<f32>, ..1] = [ManagedNode {
         next: Val {
-            val: @ManagedNode {
+            val: box(GC) ManagedNode {
                 next: Empty,
                 value: 17.5,
             }
@@ -255,7 +256,7 @@ fn main() {
 
     let borrowed_managed: &ManagedNode<f64> = &ManagedNode {
         next: Val {
-            val: @ManagedNode {
+            val: box(GC) ManagedNode {
                 next: Empty,
                 value: 19.5,
             }
diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs
index 787c1cdea80..3328b112284 100644
--- a/src/test/debuginfo/var-captured-in-nested-closure.rs
+++ b/src/test/debuginfo/var-captured-in-nested-closure.rs
@@ -51,6 +51,8 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+use std::gc::GC;
+
 struct Struct {
     a: int,
     b: f64,
@@ -69,7 +71,7 @@ fn main() {
 
     let struct_ref = &a_struct;
     let owned = box 6;
-    let managed = @7;
+    let managed = box(GC) 7;
 
     let closure = || {
         let closure_local = 8;
diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs
index fc8093304db..453ac354631 100644
--- a/src/test/debuginfo/var-captured-in-stack-closure.rs
+++ b/src/test/debuginfo/var-captured-in-stack-closure.rs
@@ -31,6 +31,8 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+use std::gc::GC;
+
 struct Struct {
     a: int,
     b: f64,
@@ -49,7 +51,7 @@ fn main() {
 
     let struct_ref = &a_struct;
     let owned = box 6;
-    let managed = @7;
+    let managed = box(GC) 7;
 
     let closure = || {
         zzz();