---

yaml
---
r: 16322
b: refs/heads/try
c: 8ebbf46
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: e8dfe179da7ff0c679d6020fe658c8edd076a602
+refs/heads/try: 8ebbf464f59f3a400de91d7afac0c254e3346c72
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/test/auxiliary/cci_nested_lib.rs

@@ -1,29 +1,29 @@
-type alist<A,B> = { eq_fn: fn@(A,A) -> bool, mut data: [(A,B)] };
+import dvec::{dvec,extensions};
+
+type entry<A,B> = {key: A, value: B};
+type alist<A,B> = { eq_fn: fn@(A,A) -> bool, data: dvec<entry<A,B>> };
 
 fn alist_add<A: copy, B: copy>(lst: alist<A,B>, k: A, v: B) {
-    lst.data += [(k, v)];
+    lst.data.push({key:k, value:v});
 }
 
 fn alist_get<A: copy, B: copy>(lst: alist<A,B>, k: A) -> B {
     let eq_fn = lst.eq_fn;
-    for lst.data.each {|pair|
-        let (ki, vi) = pair; // copy req'd for alias analysis
-        if eq_fn(k, ki) { ret vi; }
+    for lst.data.each {|entry|
+        if eq_fn(entry.key, k) { ret entry.value; }
     }
     fail;
 }
 
 #[inline]
 fn new_int_alist<B: copy>() -> alist<int, B> {
     fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-    ret {eq_fn: eq_int,
-         mut data: []};
+    ret {eq_fn: eq_int, data: dvec()};
 }
 
 #[inline]
 fn new_int_alist_2<B: copy>() -> alist<int, B> {
     #[inline]
     fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-    ret {eq_fn: eq_int,
-         mut data: []};
+    ret {eq_fn: eq_int, data: dvec()};
 }

branches/try/src/test/compile-fail/issue-511.rs

@@ -8,4 +8,6 @@ fn f<T>(&o: option<T>) {
 fn main() {
     f::<int>(option::none);
     //!^ ERROR taking mut reference to static item
+    //!^^ ERROR illegal borrow unless pure: creating mutable alias to aliasable, immutable memory
+    //!^^^ NOTE impure due to access to impure function
 }

branches/try/src/test/run-pass/alt-pattern-drop.rs

@@ -25,8 +25,10 @@ fn foo(s: @int) {
 fn main() {
     let s: @int = @0; // ref up
 
+    let count = dbg::refcount(s);
+
     foo(s); // ref up then down
 
     log(debug, dbg::refcount(s));
-    assert (dbg::refcount(s) == 1u);
+    assert (dbg::refcount(s) == count);
 }

branches/try/src/test/run-pass/class-implements-multiple-ifaces.rs

@@ -1,6 +1,7 @@
 use std;
 import std::map::*;
 import vec::*;
+import dvec::{dvec, extensions};
 
 enum furniture { chair, couch, bed }
 enum body_part { finger, toe, nose, ear }
@@ -26,7 +27,7 @@ fn vec_includes<T>(xs: [T], x: T) -> bool {
 class cat implements noisy, scratchy, bitey {
   priv {
     let meows : @mut uint;
-    let scratched : @mut [furniture];
+    let scratched : dvec<furniture>;
     let bite_counts : hashmap<body_part, uint>;
 
     fn meow() -> uint {
@@ -44,7 +45,7 @@ class cat implements noisy, scratchy, bitey {
 
   new(in_x : uint, in_y : int, in_name: str)
     { self.meows = @mut in_x; self.how_hungry = @mut in_y;
-      self.name = in_name; self.scratched = @mut [];
+      self.name = in_name; self.scratched = dvec();
       let hsher: hashfn<body_part> =
         fn@(p: body_part) -> uint { int::hash(p as int) };
       let eqer : eqfn<body_part> =
@@ -61,10 +62,10 @@ class cat implements noisy, scratchy, bitey {
   fn meow_count() -> uint { *self.meows }
   fn scratch() -> option<furniture> {
     let all = [chair, couch, bed];
-    log(error, *(self.scratched));
+    log(error, self.scratched);
     let mut rslt = none;
-    for each(all) {|thing| if !vec_includes(*(self.scratched), thing) {
-          *self.scratched += [thing];
+    for each(all) {|thing| if !self.scratched.contains(thing) {
+          self.scratched.push(thing);
           ret some(thing); }}
     rslt
   }

branches/try/src/test/run-pass/iface-cast.rs

@@ -26,10 +26,9 @@ impl of to_str for int {
 
 impl of to_str for Tree {
     fn to_str() -> str {
-        #fmt["[%s, %s, %s]",
-             self.val.to_str(),
-             self.left.to_str(),
-             self.right.to_str()]
+        let l = self.left, r = self.right;
+        #fmt["[%s, %s, %s]", self.val.to_str(),
+             l.to_str(), r.to_str()]
     }
 }
 

branches/try/src/test/run-pass/maybe-mutable.rs

@@ -4,7 +4,7 @@
 // -*- rust -*-
 fn len(v: [const int]) -> uint {
     let mut i = 0u;
-    for v.each {|x| i += 1u; }
+    while i < vec::len(v) { i += 1u; }
     ret i;
 }