Serialize constraints in types (literal arguments still not supported)

This involved, in part, changing the ast::def type so that a def_fn
has a "purity" field. This lets the typechecker determine whether
functions defined in other crates are pure.

It also required updating some error messages in tests. As a test
for cross-crate constrained functions, I added a safe_slice function
to std::str (slice(), with one of the asserts replaced with a
function precondition) and some test cases (various versions of
fn-constraint.rs) that call it. Also, I changed "fn" to "pred" for
some of the boolean functions in std::uint.

2 files changed, 14 insertions, 6 deletions

diff --git a/src/lib/str.rs b/src/lib/str.rs
index 51b876e3253..3ad63093ddc 100644
--- a/src/lib/str.rs
+++ b/src/lib/str.rs
@@ -1,6 +1,7 @@
 
 import rustrt::sbuf;
 import vec::rustrt::vbuf;
+import uint::le;
 export sbuf;
 export rustrt;
 export eq;
@@ -45,6 +46,7 @@ export split;
 export concat;
 export connect;
 export to_upper;
+export safe_slice;
 
 native "rust" mod rustrt {
     type sbuf;
@@ -381,6 +383,12 @@ fn slice(str s, uint begin, uint end) -> str {
     ret rustrt::str_slice(s, begin, end);
 }
 
+fn safe_slice(str s, uint begin, uint end) : le(begin, end) -> str {
+    assert (end <= str::byte_len(s)); // would need some magic to
+                                      // make this a precondition
+    ret rustrt::str_slice(s, begin, end);
+}
+
 fn shift_byte(&mutable str s) -> u8 {
     auto len = byte_len(s);
     assert (len > 0u);
diff --git a/src/lib/uint.rs b/src/lib/uint.rs
index 27c0a0e458e..ca632914a45 100644
--- a/src/lib/uint.rs
+++ b/src/lib/uint.rs
@@ -10,17 +10,17 @@ fn div(uint x, uint y) -> uint { ret x / y; }
 
 fn rem(uint x, uint y) -> uint { ret x % y; }
 
-fn lt(uint x, uint y) -> bool { ret x < y; }
+pred lt(uint x, uint y) -> bool { ret x < y; }
 
-fn le(uint x, uint y) -> bool { ret x <= y; }
+pred le(uint x, uint y) -> bool { ret x <= y; }
 
-fn eq(uint x, uint y) -> bool { ret x == y; }
+pred eq(uint x, uint y) -> bool { ret x == y; }
 
-fn ne(uint x, uint y) -> bool { ret x != y; }
+pred ne(uint x, uint y) -> bool { ret x != y; }
 
-fn ge(uint x, uint y) -> bool { ret x >= y; }
+pred ge(uint x, uint y) -> bool { ret x >= y; }
 
-fn gt(uint x, uint y) -> bool { ret x > y; }
+pred gt(uint x, uint y) -> bool { ret x > y; }
 
 fn max(uint x, uint y) -> uint { if (x > y) { ret x; } ret y; }