libsyntax: Remove @const from the language

Author: pcwalton

src/libcore/managed.rs

@@ -49,23 +49,43 @@ pub pure fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
 }
 
 #[cfg(notest)]
-impl<T:Eq> Eq for @const T {
+impl<T:Eq> Eq for @T {
     #[inline(always)]
-    pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
+    pure fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
-    pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
+    pure fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
 }
 
 #[cfg(notest)]
-impl<T:Ord> Ord for @const T {
+impl<T:Eq> Eq for @mut T {
     #[inline(always)]
-    pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
+    pure fn eq(&self, other: &@mut T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
-    pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
+    pure fn ne(&self, other: &@mut T) -> bool { *(*self) != *(*other) }
+}
+
+#[cfg(notest)]
+impl<T:Ord> Ord for @T {
+    #[inline(always)]
+    pure fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
+    #[inline(always)]
+    pure fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) }
+    #[inline(always)]
+    pure fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) }
+    #[inline(always)]
+    pure fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
+}
+
+#[cfg(notest)]
+impl<T:Ord> Ord for @mut T {
+    #[inline(always)]
+    pure fn lt(&self, other: &@mut T) -> bool { *(*self) < *(*other) }
+    #[inline(always)]
+    pure fn le(&self, other: &@mut T) -> bool { *(*self) <= *(*other) }
     #[inline(always)]
-    pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
+    pure fn ge(&self, other: &@mut T) -> bool { *(*self) >= *(*other) }
     #[inline(always)]
-    pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
+    pure fn gt(&self, other: &@mut T) -> bool { *(*self) > *(*other) }
 }
 
 #[test]

src/libsyntax/parse/obsolete.rs

@@ -58,6 +58,7 @@ pub enum ObsoleteSyntax {
     ObsoleteMode,
     ObsoleteImplicitSelf,
     ObsoleteLifetimeNotation,
+    ObsoleteConstManagedPointer,
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -193,6 +194,10 @@ pub impl Parser {
                 "instead of `&foo/bar`, write `&'foo bar`; instead of \
                  `bar/&foo`, write `&bar<'foo>"
             ),
+            ObsoleteConstManagedPointer => (
+                "const `@` pointer",
+                "instead of `@const Foo`, write `@Foo`"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);

src/libsyntax/parse/parser.rs

@@ -79,7 +79,7 @@ use parse::obsolete::{ObsoleteRecordType, ObsoleteRecordPattern};
 use parse::obsolete::{ObsoleteAssertion, ObsoletePostFnTySigil};
 use parse::obsolete::{ObsoleteBareFnType, ObsoleteNewtypeEnum};
 use parse::obsolete::{ObsoleteMode, ObsoleteImplicitSelf};
-use parse::obsolete::{ObsoleteLifetimeNotation};
+use parse::obsolete::{ObsoleteLifetimeNotation, ObsoleteConstManagedPointer};
 use parse::prec::{as_prec, token_to_binop};
 use parse::token::{can_begin_expr, is_ident, is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, special_idents};
@@ -710,6 +710,9 @@ pub impl Parser {
         if mt.mutbl != m_imm && sigil == OwnedSigil {
             self.obsolete(*self.last_span, ObsoleteMutOwnedPointer);
         }
+        if mt.mutbl == m_const && sigil == ManagedSigil {
+            self.obsolete(*self.last_span, ObsoleteConstManagedPointer);
+        }
 
         ctor(mt)
     }
@@ -1636,6 +1639,10 @@ pub impl Parser {
           token::AT => {
             self.bump();
             let m = self.parse_mutability();
+            if m == m_const {
+                self.obsolete(*self.last_span, ObsoleteConstManagedPointer);
+            }
+
             let e = self.parse_prefix_expr();
             hi = e.span.hi;
             // HACK: turn @[...] into a @-evec

src/test/compile-fail/borrowck-assign-to-subfield.rs

@@ -13,7 +13,6 @@ fn main() {
         a: int,
         w: B,
         x: @B,
-        y: @const B,
         z: @mut B
     }
     struct B {
@@ -23,7 +22,6 @@ fn main() {
         a: 1,
         w: B {a: 1},
         x: @B {a: 1},
-        y: @const B {a: 1},
         z: @mut B {a: 1}
     };
 
@@ -37,6 +35,5 @@ fn main() {
     // in these cases we pass through a box, so the mut
     // of the box is dominant
     p.x.a = 2;     //~ ERROR assigning to immutable field
-    p.y.a = 2;     //~ ERROR assigning to const field
     p.z.a = 2;
 }

src/test/compile-fail/borrowck-pat-enum-in-box.rs

@@ -50,18 +50,6 @@ fn box_imm_recs(v: @Outer) {
     borrow(v.f.g.h); // OK
 }
 
-fn box_const(v: @const ~int) {
-    borrow(*v); //~ ERROR illegal borrow unless pure
-}
-
-fn box_const_rec(v: @const Rec) {
-    borrow(v.f); //~ ERROR illegal borrow unless pure
-}
-
-fn box_const_recs(v: @const Outer) {
-    borrow(v.f.g.h); //~ ERROR illegal borrow unless pure
-}
-
 fn main() {
 }
 

src/test/compile-fail/borrowck-uniq-via-box.rs

@@ -11,7 +11,6 @@
 #[legacy_modes];
 
 fn takes_mut(&&x: @mut int) { }
-fn takes_const(&&x: @const int) { }
 fn takes_imm(&&x: @int) { }
 
 fn apply<T>(t: T, f: &fn(T)) {
@@ -20,10 +19,8 @@ fn apply<T>(t: T, f: &fn(T)) {
 
 fn main() {
     apply(@3, takes_mut); //~ ERROR (values differ in mutability)
-    apply(@3, takes_const);
     apply(@3, takes_imm);
 
     apply(@mut 3, takes_mut);
-    apply(@mut 3, takes_const);
     apply(@mut 3, takes_imm); //~ ERROR (values differ in mutability)
 }

src/test/compile-fail/coerce-bad-variance.rs

@@ -25,9 +25,6 @@ fn main() {
     // @mut int.
     let f: @mut int = r();
 
-    // OK.
-    let g: @const int = r();
-
     // Bad.
     let h: @int = r(); //~ ERROR (values differ in mutability)
 }

src/test/compile-fail/fn-variance-1.rs

@@ -10,22 +10,12 @@
 
 trait Mumbo {
     fn jumbo(&self, x: @uint) -> uint;
-    fn jambo(&self, x: @const uint) -> uint;
-    fn jbmbo(&self) -> @uint;
 }
 
 impl Mumbo for uint {
     // Cannot have a larger effect than the trait:
     unsafe fn jumbo(&self, x: @uint) { *self + *x; }
     //~^ ERROR expected impure fn but found unsafe fn
-
-    // Cannot accept a narrower range of parameters:
-    fn jambo(&self, x: @uint) { *self + *x; }
-    //~^ ERROR values differ in mutability
-
-    // Cannot return a wider range of values:
-    fn jbmbo(&self) -> @const uint { @const 0 }
-    //~^ ERROR values differ in mutability
 }
 
 fn main() {}