Merge branch 'master' of git://github.com/graydon/rust

Conflicts:
	src/boot/fe/ast.ml

5 files changed, 136 insertions, 40 deletions

diff --git a/src/test/run-pass/destructor-ordering.rs b/src/test/run-pass/destructor-ordering.rs
index 99479c55..f7f5b8c8 100644
--- a/src/test/run-pass/destructor-ordering.rs
+++ b/src/test/run-pass/destructor-ordering.rs
@@ -1,58 +1,93 @@
-// We share an instance of this type among all the destructor-order
-// checkers.  It tracks how many destructors have run so far and
-// 'fail's when one runs out of order.
-// FIXME: Make it easier to collect a failure message.
-state obj order_tracker(mutable int init) {
-  fn assert_order(int expected, str fail_message) {
-    if (expected != init) {
-      log expected;
+// This test checks that destructors run in the right order.  Because
+// stateful objects can't have destructors, we have the destructors
+// record their expected order into a channel when they execute (so
+// the object becomes 'io' rather than 'state').  Then each test case
+// asserts that the channel produces values in ascending order.
+//
+// FIXME: Write an int->str function and concatenate the whole failure
+// message into a single log statement (or, even better, a print).
+//
+// FIXME: check_order should take only 1 line in a test, not 2+a block
+// block. Since destructor-having objects can't refer to mutable state
+// (like the port), we'd need a with-like construct to do the same for
+// stateful objects within a scope.
+//
+// FIXME #21: Each test should execute in its own task, so it can fail
+// independently, writing its error message to a channel that the
+// parent task aggregates.
+
+type order_info = rec(int order, str msg);
+
+io fn check_order(port[order_info] expected_p) {
+  chan(expected_p) <| rec(order=-1, msg="");
+  let mutable int actual = 0;
+  auto expected <- expected_p;  // FIXME #121: Workaround for while(true) bug.
+  auto done = -1;  // FIXME: Workaround for typechecking bug.
+  while(expected.order != done) {
+    if (expected.order != actual) {
+      log expected.order;
       log " != ";
-      log init;
-      log fail_message;
+      log actual;
+      log expected.msg;
       fail;
     }
-    init += 1;
+    actual += 1;
+    expected <- expected_p;
   }
 }
 
 
-obj dorder(@order_tracker tracker, int order, str message) {
+obj dorder(chan[order_info] expected, int order, str message) {
   drop {
-    tracker.assert_order(order, message);
+    expected <| rec(order=order, msg=message);
   }
 }
 
-fn test_simple() {
-  auto tracker = @order_tracker(0);
+io fn test_simple() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
   dorder(tracker, 1, "Reverse decl order");
   dorder(tracker, 0, "Reverse decl order");
+  check_order(tracker_p);
 }
 
-fn test_block() {
-  auto tracker = @order_tracker(0);
-  dorder(tracker, 2, "Before block");
+io fn test_block() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
   {
-    dorder(tracker, 0, "Inside block");
+    dorder(tracker, 2, "Before block");
+    {
+      dorder(tracker, 0, "Inside block");
+    }
+    dorder(tracker, 1, "After block");
   }
-  dorder(tracker, 1, "After block");
+  check_order(tracker_p);
 }
 
-fn test_decl_v_init() {
-  auto tracker = @order_tracker(0);
-  auto var1;
-  auto var2;
-  var2 = dorder(tracker, 0, "decl, not init");
-  var1 = dorder(tracker, 1, "decl, not init");
+io fn test_decl_v_init() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  {
+    auto var1;
+    auto var2;
+    var2 = dorder(tracker, 0, "decl, not init");
+    var1 = dorder(tracker, 1, "decl, not init");
+  }
+  check_order(tracker_p);
 }
 
-fn test_overwritten_obj() {
-  auto tracker = @order_tracker(0);
-  auto var1 = dorder(tracker, 0, "overwritten object destroyed first");
-  auto var2 = dorder(tracker, 2, "destroyed at end of scope");
-  var1 = dorder(tracker, 3, "overwriter deleted in rev decl order");
+io fn test_overwritten_obj() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
   {
-    dorder(tracker, 1, "overwritten object destroyed before end of scope");
+    auto var1 = dorder(tracker, 0, "overwritten object destroyed first");
+    auto var2 = dorder(tracker, 2, "destroyed at end of scope");
+    var1 = dorder(tracker, 3, "overwriter deleted in rev decl order");
+    {
+      dorder(tracker, 1, "overwritten object destroyed before end of scope");
+    }
   }
+  check_order(tracker_p);
 }
 
 // Used to embed dorder objects into an expression.  Note that the
@@ -60,17 +95,21 @@ fn test_overwritten_obj() {
 fn combine_dorders(dorder d1, dorder d2) -> int {
   ret 1;
 }
-fn test_expression_destroyed_right_to_left() {
-  auto tracker = @order_tracker(0);
-  combine_dorders(dorder(tracker, 4, ""), dorder(tracker, 3, ""))
-    / combine_dorders(dorder(tracker, 2, ""), dorder(tracker, 1, ""));
+io fn test_expression_destroyed_right_to_left() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
   {
-    dorder(tracker, 0,
-           "expression objects live to end of block, not statement");
+    combine_dorders(dorder(tracker, 4, ""), dorder(tracker, 3, ""))
+      / combine_dorders(dorder(tracker, 2, ""), dorder(tracker, 1, ""));
+    {
+      dorder(tracker, 0,
+             "expression objects live to end of block, not statement");
+    }
   }
+  check_order(tracker_p);
 }
 
-fn main() {
+io fn main() {
   test_simple();
   test_block();
   test_decl_v_init();
diff --git a/src/test/run-pass/int-lib.rs b/src/test/run-pass/int-lib.rs
new file mode 100644
index 00000000..ce39de43
--- /dev/null
+++ b/src/test/run-pass/int-lib.rs
@@ -0,0 +1,15 @@
+use std;
+
+import std._int;
+
+fn test_to_str() {
+  check (_int.to_str(0, 10u) == "0");
+  check (_int.to_str(1, 10u) == "1");
+  check (_int.to_str(-1, 10u) == "-1");
+  check (_int.to_str(255, 16u) == "ff");
+  check (_int.to_str(-71, 36u) == "-1z");
+}
+
+fn main() {
+  test_to_str();
+}
diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
new file mode 100644
index 00000000..fe7d147c
--- /dev/null
+++ b/src/test/run-pass/integral-indexing.rs
@@ -0,0 +1,22 @@
+// This is a testcase for issue #94.
+
+fn main() {
+
+  let vec[int] v = vec(0, 1, 2, 3, 4, 5);
+  let str s = "abcdef";
+  check (v.(3u) == 3);
+  check (v.(3u8) == 3);
+  check (v.(3i8) == 3);
+  check (v.(3u32) == 3);
+  check (v.(3i32) == 3);
+
+  log v.(3u8);
+
+  check (s.(3u) == 'd' as u8);
+  check (s.(3u8) == 'd' as u8);
+  check (s.(3i8) == 'd' as u8);
+  check (s.(3u32) == 'd' as u8);
+  check (s.(3i32) == 'd' as u8);
+
+  log s.(3u8);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/lib-map.rs b/src/test/run-pass/lib-map.rs
index 11101c84..058fb237 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -4,13 +4,17 @@ use std;
 import std.map;
 
 fn test_simple() {
+  log "*** starting test_simple";
+
   fn eq(&uint x, &uint y) -> bool { ret x == y; }
 
   let map.hashfn[uint] hasher = std.util.id[uint];
   let map.eqfn[uint] eqer = eq;
   let map.hashmap[uint, uint] hm = map.mk_hashmap[uint, uint](hasher, eqer);
+
+  log "*** finished test_simple";
 }
 
 fn main() {
   test_simple();
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/str-lib.rs b/src/test/run-pass/str-lib.rs
new file mode 100644
index 00000000..585f9b8d
--- /dev/null
+++ b/src/test/run-pass/str-lib.rs
@@ -0,0 +1,16 @@
+use std;
+import std._str;
+
+fn test_bytes_len() {
+  check (_str.byte_len("") == 0u);
+  check (_str.byte_len("hello world") == 11u);
+  check (_str.byte_len("\x63") == 1u);
+  check (_str.byte_len("\xa2") == 2u);
+  check (_str.byte_len("\u03c0") == 2u);
+  check (_str.byte_len("\u2620") == 3u);
+  check (_str.byte_len("\U0001d11e") == 4u);
+}
+
+fn main() {
+  test_bytes_len();
+}