librustc: Make the compiler ignore purity.

For bootstrapping purposes, this commit does not remove all uses of
the keyword "pure" -- doing so would cause the compiler to no longer
bootstrap due to some syntax extensions ("deriving" in particular).
Instead, it makes the compiler ignore "pure". Post-snapshot, we can
remove "pure" from the language.

There are quite a few (~100) borrow check errors that were essentially
all the result of mutable fields or partial borrows of `@mut`. Per
discussions with Niko I think we want to allow partial borrows of
`@mut` but detect obvious footguns. We should also improve the error
message when `@mut` is erroneously reborrowed.

doc/rust.md

@@ -214,7 +214,7 @@ false fn for
 if impl
 let loop
 match mod mut
-priv pub pure
+priv pub
 ref return
 self static struct super
 true trait type
@@ -936,7 +936,6 @@ Specifically, the following operations are considered unsafe:
 
   - Dereferencing a [raw pointer](#pointer-types).
   - Casting a [raw pointer](#pointer-types) to a safe pointer type.
-  - Breaking the [purity-checking rules](#pure-functions) in a `pure` function.
   - Calling an unsafe function.
 
 ##### Unsafe blocks
@@ -946,42 +945,6 @@ This facility exists because the static semantics of Rust are a necessary approx
 When a programmer has sufficient conviction that a sequence of unsafe operations is actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The compiler will consider uses of such code "safe", to the surrounding context.
 
 
-#### Pure functions
-
-A pure function declaration is identical to a function declaration, except that
-it is declared with the additional keyword `pure`. In addition, the typechecker
-checks the body of a pure function with a restricted set of typechecking rules.
-A pure function may only modify data owned by its own stack frame.
-So, a pure function may modify a local variable allocated on the stack, but not a mutable reference that it takes as an argument.
-A pure function may only call other pure functions, not general functions.
-
-An example of a pure function:
-
-~~~~
-pure fn lt_42(x: int) -> bool {
-    return (x < 42);
-}
-~~~~
-
-Pure functions may call other pure functions:
-
-~~~~{.xfail-test}
-pure fn pure_length<T>(ls: List<T>) -> uint { ... }
-
-pure fn nonempty_list<T>(ls: List<T>) -> bool { pure_length(ls) > 0u }
-~~~~
-
-These purity-checking rules approximate the concept of referential transparency:
-that a call-expression could be rewritten with the literal-expression of its return value, without changing the meaning of the program.
-Since they are an approximation, sometimes these rules are *too* restrictive.
-Rust allows programmers to violate these rules using [`unsafe` blocks](#unsafe-blocks), which we already saw.
-As with any `unsafe` block, those that violate static purity carry transfer the burden of safety-proof from the compiler to the programmer.
-Programmers should exercise caution when breaking such rules.
-
-For more details on purity, see [the borrowed pointer tutorial][borrow].
-
-[borrow]: tutorial-borrowed-ptr.html
-
 #### Diverging functions
 
 A special kind of function can be declared with a `!` character where the
@@ -1246,10 +1209,10 @@ For example:
 
 ~~~~
 trait Num {
-    static pure fn from_int(n: int) -> Self;
+    static fn from_int(n: int) -> Self;
 }
 impl Num for float {
-    static pure fn from_int(n: int) -> float { n as float }
+    static fn from_int(n: int) -> float { n as float }
 }
 let x: float = Num::from_int(42);
 ~~~~
@@ -2643,7 +2606,7 @@ Raw pointers (`*`)
 ### Function types
 
 The function type-constructor `fn` forms new function types. A function type
-consists of a set of function-type modifiers (`pure`, `unsafe`, `extern`, etc.),
+consists of a set of function-type modifiers (`unsafe`, `extern`, etc.),
 a sequence of input slots and an output slot.
 
 An example of a `fn` type:

doc/tutorial-borrowed-ptr.md

@@ -486,12 +486,12 @@ For example, we could write a subroutine like this:
 
 ~~~
 struct Point {x: float, y: float}
-fn get_x(p: &r/Point) -> &r/float { &p.x }
+fn get_x(p: &'r Point) -> &'r float { &p.x }
 ~~~
 
 Here, the function `get_x()` returns a pointer into the structure it
-was given. The type of the parameter (`&r/Point`) and return type
-(`&r/float`) both use a new syntactic form that we have not seen so
+was given. The type of the parameter (`&'r Point`) and return type
+(`&'r float`) both use a new syntactic form that we have not seen so
 far.  Here the identifier `r` names the lifetime of the pointer
 explicitly. So in effect, this function declares that it takes a
 pointer with lifetime `r` and returns a pointer with that same
@@ -572,8 +572,8 @@ function:
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
-fn select<T>(shape: &r/Shape, threshold: float,
-             a: &r/T, b: &r/T) -> &r/T {
+fn select<T>(shape: &'r Shape, threshold: float,
+             a: &'r T, b: &'r T) -> &'r T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~
@@ -593,17 +593,17 @@ example:
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
 # fn select<T>(shape: &Shape, threshold: float,
-#              a: &r/T, b: &r/T) -> &r/T {
+#              a: &'r T, b: &'r T) -> &'r T {
 #     if compute_area(shape) > threshold {a} else {b}
 # }
-                                                  // -+ r
-fn select_based_on_unit_circle<T>(                //  |-+ B
-    threshold: float, a: &r/T, b: &r/T) -> &r/T { //  | |
-                                                  //  | |
-    let shape = Circle(Point {x: 0., y: 0.}, 1.); //  | |
-    select(&shape, threshold, a, b)               //  | |
-}                                                 //  |-+
-                                                  // -+
+                                                     // -+ r
+fn select_based_on_unit_circle<T>(                   //  |-+ B
+    threshold: float, a: &'r T, b: &'r T) -> &'r T { //  | |
+                                                     //  | |
+    let shape = Circle(Point {x: 0., y: 0.}, 1.);    //  | |
+    select(&shape, threshold, a, b)                  //  | |
+}                                                    //  |-+
+                                                     // -+
 ~~~
 
 In this call to `select()`, the lifetime of the first parameter shape
@@ -629,8 +629,8 @@ returned. Here is how the new `select()` might look:
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
-fn select<T>(shape: &tmp/Shape, threshold: float,
-             a: &r/T, b: &r/T) -> &r/T {
+fn select<T>(shape: &'tmp Shape, threshold: float,
+             a: &'r T, b: &'r T) -> &'r T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~
@@ -649,7 +649,7 @@ concise to just omit the named lifetime for `shape` altogether:
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
 fn select<T>(shape: &Shape, threshold: float,
-             a: &r/T, b: &r/T) -> &r/T {
+             a: &'r T, b: &'r T) -> &'r T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~

src/libcore/cell.rs

@@ -8,18 +8,29 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use cast::transmute;
 use option;
 use prelude::*;
 
 /// A dynamic, mutable location.
 ///
 /// Similar to a mutable option type, but friendlier.
 
-#[deriving_eq]
 pub struct Cell<T> {
     mut value: Option<T>
 }
 
+impl<T:cmp::Eq> cmp::Eq for Cell<T> {
+    pure fn eq(&self, other: &Cell<T>) -> bool {
+        unsafe {
+            let frozen_self: &Option<T> = transmute(&mut self.value);
+            let frozen_other: &Option<T> = transmute(&mut other.value);
+            frozen_self == frozen_other
+        }
+    }
+    pure fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) }
+}
+
 /// Creates a new full cell with the given value.
 pub fn Cell<T>(value: T) -> Cell<T> {
     Cell { value: Some(value) }

src/libcore/comm.rs

@@ -8,10 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use cast;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use option;
 use option::{Option, Some, None, unwrap};
+use uint;
 use unstable;
 use vec;
 
@@ -283,8 +285,12 @@ impl<T: Owned> Peekable<T> for PortSet<T> {
 pure fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool {
     // It'd be nice to use self.port.each, but that version isn't
     // pure.
-    for vec::each(self.ports) |p| {
-        if p.peek() { return true }
+    for uint::range(0, vec::uniq_len(&const self.ports)) |i| {
+        // XXX: Botch pending demuting.
+        unsafe {
+            let port: &Port<T> = cast::transmute(&mut self.ports[i]);
+            if port.peek() { return true }
+        }
     }
     false
 }

src/libcore/container.rs

@@ -14,10 +14,10 @@ use option::Option;
 
 pub trait Container {
     /// Return the number of elements in the container
-    pure fn len(&self) -> uint;
+    pure fn len(&const self) -> uint;
 
     /// Return true if the container contains no elements
-    pure fn is_empty(&self) -> bool;
+    pure fn is_empty(&const self) -> bool;
 }
 
 pub trait Mutable: Container {

src/libcore/hashmap.rs

@@ -290,10 +290,10 @@ pub mod linear {
 
     impl<K:Hash + IterBytes + Eq,V> Container for LinearMap<K, V> {
         /// Return the number of elements in the map
-        pure fn len(&self) -> uint { self.size }
+        pure fn len(&const self) -> uint { self.size }
 
         /// Return true if the map contains no elements
-        pure fn is_empty(&self) -> bool { self.len() == 0 }
+        pure fn is_empty(&const self) -> bool { self.len() == 0 }
     }
 
     impl<K:Hash + IterBytes + Eq,V> Mutable for LinearMap<K, V> {
@@ -555,10 +555,10 @@ pub mod linear {
 
     impl<T:Hash + IterBytes + Eq> Container for LinearSet<T> {
         /// Return the number of elements in the set
-        pure fn len(&self) -> uint { self.map.len() }
+        pure fn len(&const self) -> uint { self.map.len() }
 
         /// Return true if the set contains no elements
-        pure fn is_empty(&self) -> bool { self.map.is_empty() }
+        pure fn is_empty(&const self) -> bool { self.map.is_empty() }
     }
 
     impl<T:Hash + IterBytes + Eq> Mutable for LinearSet<T> {

src/libcore/io.rs

@@ -1116,7 +1116,7 @@ pub struct BytesWriter {
 impl Writer for BytesWriter {
     fn write(&self, v: &[const u8]) {
         let v_len = v.len();
-        let bytes_len = self.bytes.len();
+        let bytes_len = vec::uniq_len(&const self.bytes);
 
         let count = uint::max(bytes_len, self.pos + v_len);
         vec::reserve(&mut self.bytes, count);
@@ -1131,7 +1131,7 @@ impl Writer for BytesWriter {
     }
     fn seek(&self, offset: int, whence: SeekStyle) {
         let pos = self.pos;
-        let len = self.bytes.len();
+        let len = vec::uniq_len(&const self.bytes);
         self.pos = seek_in_buf(offset, pos, len, whence);
     }
     fn tell(&self) -> uint { self.pos }

src/libcore/mutable.rs

@@ -46,8 +46,7 @@ pub fn unwrap<T>(m: Mut<T>) -> T {
 pub impl<T> Data<T> {
     fn borrow_mut<R>(&self, op: &fn(t: &mut T) -> R) -> R {
         match self.mode {
-            Immutable => fail!(fmt!("%? currently immutable",
-                                   self.value)),
+            Immutable => fail!(~"currently immutable"),
             ReadOnly | Mutable => {}
         }
 
@@ -62,8 +61,7 @@ pub impl<T> Data<T> {
 
     fn borrow_imm<R>(&self, op: &fn(t: &T) -> R) -> R {
         match self.mode {
-          Mutable => fail!(fmt!("%? currently mutable",
-                               self.value)),
+          Mutable => fail!(~"currently mutable"),
           ReadOnly | Immutable => {}
         }
 

src/libcore/option.rs

@@ -228,14 +228,14 @@ pub pure fn while_some<T>(x: Option<T>, blk: &fn(v: T) -> Option<T>) {
 }
 
 #[inline(always)]
-pub pure fn is_none<T>(opt: &Option<T>) -> bool {
+pub pure fn is_none<T>(opt: &const Option<T>) -> bool {
     //! Returns true if the option equals `none`
 
     match *opt { None => true, Some(_) => false }
 }
 
 #[inline(always)]
-pub pure fn is_some<T>(opt: &Option<T>) -> bool {
+pub pure fn is_some<T>(opt: &const Option<T>) -> bool {
     //! Returns true if the option contains some value
 
     !is_none(opt)
@@ -333,11 +333,11 @@ impl<T> MutableIter<T> for Option<T> {
 pub impl<T> Option<T> {
     /// Returns true if the option equals `none`
     #[inline(always)]
-    pure fn is_none(&self) -> bool { is_none(self) }
+    pure fn is_none(&const self) -> bool { is_none(self) }
 
     /// Returns true if the option contains some value
     #[inline(always)]
-    pure fn is_some(&self) -> bool { is_some(self) }
+    pure fn is_some(&const self) -> bool { is_some(self) }
 
     /**
      * Update an optional value by optionally running its content by reference

src/libcore/ptr.rs

@@ -223,20 +223,20 @@ pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) {
 }
 
 pub trait Ptr<T> {
-    pure fn is_null(&self) -> bool;
-    pure fn is_not_null(&self) -> bool;
+    pure fn is_null(&const self) -> bool;
+    pure fn is_not_null(&const self) -> bool;
     pure fn offset(&self, count: uint) -> Self;
 }
 
 /// Extension methods for immutable pointers
 impl<T> Ptr<T> for *T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
-    pure fn is_null(&self) -> bool { is_null(*self) }
+    pure fn is_null(&const self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
+    pure fn is_not_null(&const self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a pointer.
     #[inline(always)]
@@ -247,11 +247,11 @@ impl<T> Ptr<T> for *T {
 impl<T> Ptr<T> for *mut T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
-    pure fn is_null(&self) -> bool { is_null(*self) }
+    pure fn is_null(&const self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
+    pure fn is_not_null(&const self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a mutable pointer.
     #[inline(always)]

src/libcore/repr.rs

@@ -499,7 +499,7 @@ impl TyVisitor for ReprVisitor {
     }
 
     fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
-        match self.var_stk[self.var_stk.len() - 1] {
+        match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
             Degenerate | TagMatch => {
                 if i != 0 {
                     self.writer.write_str(", ");
@@ -517,7 +517,7 @@ impl TyVisitor for ReprVisitor {
                                 _disr_val: int,
                                 n_fields: uint,
                                 _name: &str) -> bool {
-        match self.var_stk[self.var_stk.len() - 1] {
+        match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
             Degenerate | TagMatch => {
                 if n_fields > 0 {
                     self.writer.write_char(')');

src/libcore/task/spawn.rs

@@ -127,7 +127,7 @@ type TaskGroupInner = &'self mut Option<TaskGroupData>;
 
 // A taskgroup is 'dead' when nothing can cause it to fail; only members can.
 pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool {
-    (&tg.members).is_empty()
+    (&const tg.members).is_empty()
 }
 
 // A list-like structure by which taskgroups keep track of all ancestor groups